#!/usr/bin/env python3
"""
Eden PayPal Monitor
Polls for new payments and auto-completes orders
Simpler than IPN - no server needed
"""
import sys
sys.path.append('/Eden/CORE')

import json
import sqlite3
import hashlib
import time
from datetime import datetime, timedelta
from pathlib import Path

from sage_product_catalog import SageProductCatalog

PAYPAL_EMAIL = "jamlen@hotmail.ca"
DB_PATH = "/Eden/DATA/sales.db"
PAYMENT_LOG = "/Eden/DATA/payments.json"
PHI = 1.618

class PaymentMonitor:
    """Monitor and track payments"""
    
    def __init__(self):
        self.catalog = SageProductCatalog()
        self.db_path = DB_PATH
        self.known_payments = self._load_known_payments()
        
    def _load_known_payments(self) -> set:
        """Load previously recorded payment IDs"""
        try:
            with open(PAYMENT_LOG, 'r') as f:
                data = json.load(f)
                return set(data.get('payment_ids', []))
        except:
            return set()
    
    def _save_known_payments(self):
        """Save known payment IDs"""
        with open(PAYMENT_LOG, 'w') as f:
            json.dump({
                'payment_ids': list(self.known_payments),
                'last_updated': datetime.now().isoformat()
            }, f, indent=2)
    
    def get_pending_orders(self) -> list:
        """Get all pending orders"""
        conn = sqlite3.connect(self.db_path)
        c = conn.cursor()
        c.execute("""SELECT id, product_id, customer_email, amount, created_at 
                    FROM orders WHERE status = 'pending' 
                    ORDER BY created_at DESC""")
        orders = c.fetchall()
        conn.close()
        return orders
    
    def complete_order(self, order_id: str, payment_ref: str, payer_info: str = ""):
        """Mark order as completed"""
        conn = sqlite3.connect(self.db_path)
        c = conn.cursor()
        
        # Get order details first
        c.execute("SELECT product_id, amount, customer_email FROM orders WHERE id = ?", (order_id,))
        order = c.fetchone()
        
        if not order:
            conn.close()
            return False
        
        # Update order
        c.execute("""UPDATE orders 
                    SET status = 'completed', 
                        payment_id = ?,
                        completed_at = CURRENT_TIMESTAMP
                    WHERE id = ?""", (payment_ref, order_id))
        
        conn.commit()
        conn.close()
        
        # Track payment
        self.known_payments.add(payment_ref)
        self._save_known_payments()
        
        # Log celebration
        self._celebrate_payment(order_id, order[0], order[1], payer_info)
        
        return True
    
    def record_direct_payment(self, amount: float, payer_email: str, payment_ref: str, notes: str = ""):
        """Record a payment that didn't match an order"""
        if payment_ref in self.known_payments:
            print(f"[SKIP] Payment {payment_ref} already recorded")
            return False
        
        conn = sqlite3.connect(self.db_path)
        c = conn.cursor()
        
        order_id = hashlib.sha256(f"{payment_ref}{datetime.now().isoformat()}".encode()).hexdigest()[:16].upper()
        
        c.execute("""INSERT INTO orders 
                    (id, product_id, customer_email, amount, status, payment_id, completed_at)
                    VALUES (?, 'direct_payment', ?, ?, 'completed', ?, CURRENT_TIMESTAMP)""",
                 (order_id, payer_email, amount, payment_ref))
        
        conn.commit()
        conn.close()
        
        self.known_payments.add(payment_ref)
        self._save_known_payments()
        
        self._celebrate_payment(order_id, "direct_payment", amount, payer_email)
        
        return True
    
    def _celebrate_payment(self, order_id: str, product: str, amount: float, payer: str):
        """Celebrate a successful payment!"""
        print()
        print("=" * 60)
        print("  " + "💰" * 10)
        print("  PAYMENT RECEIVED!")
        print("  " + "💰" * 10)
        print("=" * 60)
        print(f"  Order ID:  {order_id}")
        print(f"  Product:   {product}")
        print(f"  Amount:    ${amount:.2f}")
        print(f"  From:      {payer}")
        print(f"  Time:      {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print("=" * 60)
        print()
        
        # Log to file
        log_entry = {
            "timestamp": datetime.now().isoformat(),
            "order_id": order_id,
            "product": product,
            "amount": amount,
            "payer": payer
        }
        
        log_path = Path("/Eden/DATA/revenue_log.json")
        try:
            existing = json.loads(log_path.read_text()) if log_path.exists() else []
        except:
            existing = []
        existing.append(log_entry)
        log_path.write_text(json.dumps(existing, indent=2))
    
    def match_payment_to_order(self, amount: float) -> str:
        """Find a pending order matching this amount"""
        conn = sqlite3.connect(self.db_path)
        c = conn.cursor()
        
        c.execute("""SELECT id FROM orders 
                    WHERE amount = ? AND status = 'pending'
                    ORDER BY created_at DESC LIMIT 1""", (amount,))
        result = c.fetchone()
        conn.close()
        
        return result[0] if result else None
    
    def interactive_payment_entry(self):
        """Interactive mode to enter payments"""
        print("\n" + "=" * 50)
        print("  MANUAL PAYMENT ENTRY")
        print("=" * 50)
        
        # Show pending orders
        pending = self.get_pending_orders()
        if pending:
            print("\nPending Orders:")
            for i, order in enumerate(pending):
                print(f"  [{i+1}] {order[0][:8]}... | ${order[3]:.2f} | {order[2][:30]}")
        
        print("\nEnter payment details (or 'q' to quit):")
        
        while True:
            try:
                amount_str = input("  Amount ($): ").strip()
                if amount_str.lower() == 'q':
                    break
                    
                amount = float(amount_str.replace('$', '').replace(',', ''))
                
                payer = input("  Payer email/name: ").strip() or "unknown"
                ref = input("  PayPal transaction ID (or press Enter): ").strip()
                
                if not ref:
                    ref = f"MANUAL_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
                
                # Try to match to existing order
                matching_order = self.match_payment_to_order(amount)
                
                if matching_order:
                    confirm = input(f"  Found matching order {matching_order[:8]}... Complete it? (y/n): ").strip().lower()
                    if confirm == 'y':
                        self.complete_order(matching_order, ref, payer)
                    else:
                        self.record_direct_payment(amount, payer, ref)
                else:
                    print(f"  No matching order for ${amount:.2f}")
                    self.record_direct_payment(amount, payer, ref)
                
                another = input("\n  Enter another payment? (y/n): ").strip().lower()
                if another != 'y':
                    break
                    
            except ValueError:
                print("  Invalid amount, try again")
            except KeyboardInterrupt:
                break
    
    def show_dashboard(self):
        """Show payment dashboard"""
        stats = self.catalog.get_revenue_stats()
        pending = self.get_pending_orders()
        
        print("\n" + "=" * 60)
        print("  EDEN PAYMENT DASHBOARD")
        print("=" * 60)
        
        print(f"\n  💰 REVENUE")
        print(f"     Total Earned:     ${stats['total_revenue']:.2f}")
        print(f"     Completed Orders: {stats['completed_orders']}")
        print(f"     Pending Orders:   {stats['pending_orders']}")
        
        if pending:
            print(f"\n  ⏳ PENDING ORDERS ({len(pending)})")
            total_pending = 0
            for order in pending[:10]:
                print(f"     {order[0][:12]}... | ${order[3]:>7.2f} | {order[1]}")
                total_pending += order[3]
            print(f"     {'─' * 40}")
            print(f"     Potential Revenue: ${total_pending:.2f}")
        
        # Payment links reminder
        print(f"\n  🔗 PAYMENT LINK")
        print(f"     https://paypal.me/jamlen")
        
        print("\n" + "=" * 60)
    
    def watch_mode(self, interval_seconds: int = 60):
        """Continuously watch for payments (manual check prompt)"""
        print("\n" + "=" * 50)
        print("  PAYMENT WATCH MODE")
        print(f"  Checking every {interval_seconds} seconds")
        print("  Press Ctrl+C to stop")
        print("=" * 50)
        
        cycle = 0
        while True:
            try:
                cycle += 1
                now = datetime.now().strftime('%H:%M:%S')
                
                stats = self.catalog.get_revenue_stats()
                pending = self.get_pending_orders()
                
                print(f"\n[{now}] Cycle {cycle}")
                print(f"  Revenue: ${stats['total_revenue']:.2f} | Pending: {len(pending)} orders")
                
                if pending:
                    print(f"  Awaiting: ${sum(o[3] for o in pending):.2f} in pending payments")
                
                # Prompt for new payments
                check = input("  New payment received? (y/n/q): ").strip().lower()
                
                if check == 'q':
                    break
                elif check == 'y':
                    self.interactive_payment_entry()
                
                # Phi-based sleep
                time.sleep(interval_seconds * PHI)
                
            except KeyboardInterrupt:
                print("\n[STOPPED] Watch mode ended")
                break


def main():
    import argparse
    parser = argparse.ArgumentParser(description='Eden Payment Monitor')
    parser.add_argument('--dashboard', '-d', action='store_true', help='Show dashboard')
    parser.add_argument('--enter', '-e', action='store_true', help='Enter a payment')
    parser.add_argument('--watch', '-w', action='store_true', help='Watch mode')
    parser.add_argument('--amount', '-a', type=float, help='Payment amount')
    parser.add_argument('--payer', '-p', type=str, help='Payer email')
    parser.add_argument('--txn', '-t', type=str, help='Transaction ID')
    
    args = parser.parse_args()
    
    monitor = PaymentMonitor()
    
    if args.amount:
        # Quick payment entry
        ref = args.txn or f"MANUAL_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
        payer = args.payer or "unknown"
        
        matching = monitor.match_payment_to_order(args.amount)
        if matching:
            monitor.complete_order(matching, ref, payer)
        else:
            monitor.record_direct_payment(args.amount, payer, ref)
            
    elif args.enter:
        monitor.interactive_payment_entry()
    elif args.watch:
        monitor.watch_mode()
    else:
        monitor.show_dashboard()
        print("\nUsage:")
        print("  --dashboard, -d     Show payment dashboard")
        print("  --enter, -e         Enter payment interactively")
        print("  --watch, -w         Watch mode with prompts")
        print("  --amount 50 --payer email@x.com   Quick payment entry")


if __name__ == "__main__":
    main()