#!/usr/bin/env python3
"""
Anniversary Trigger - Daily job to identify and queue 12-month anniversary customers.
Runs daily at 08:00 UK time to check for customers reaching their delivery anniversary.
Includes random 0-20 minute jitter to look more natural.
Only queues new conversations within 10:15-11:45 window.
"""
import os
import random
import sys
import time
import datetime as dt
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo
from supabase import create_client


def ok_to_reply(now=None):
    """
    Check if replies are allowed (06:00–23:59:59 UK time).
    
    Args:
        now: Optional datetime to check (defaults to current UK time)
    
    Returns:
        True if within reply window, False otherwise
    """
    tz = ZoneInfo("Europe/London")
    now = now or dt.datetime.now(tz)
    # Replies allowed 06:00–00:00 (midnight)
    return dt.time(6, 0) <= now.time() <= dt.time(23, 59, 59)


def get_supabase_client():
    """Initialize Supabase client."""
    supabase_url = os.getenv('SUPABASE_URL')
    supabase_key = os.getenv('SUPABASE_SERVICE_KEY')
    
    if not supabase_url or not supabase_key:
        raise ValueError("SUPABASE_URL and SUPABASE_SERVICE_KEY must be set")
    
    return create_client(supabase_url, supabase_key)


def find_anniversary_customers():
    """
    Find customers who reached their 12-month delivery anniversary.
    Checks v_prospectable view for eligible agreements.
    """
    try:
        supabase = get_supabase_client()
        
        # Query v_prospectable view for customers at 12-month mark
        result = supabase.table('v_prospectable') \
            .select('*') \
            .execute()
        
        if not result.data or len(result.data) == 0:
            print("📭 No anniversary customers found today")
            return []
        
        print(f"📋 Found {len(result.data)} prospectable agreement(s)")
        return result.data
    
    except Exception as e:
        print(f"❌ Error finding anniversary customers: {e}")
        return []


def queue_for_campaign(agreements, campaign_tag='anniversary_12m'):
    """
    Queue eligible agreements into campaign_pool.
    
    Args:
        agreements: List of agreement records from v_prospectable
        campaign_tag: Campaign identifier (default: anniversary_12m)
    """
    if not agreements:
        return
    
    try:
        supabase = get_supabase_client()
        queued_count = 0
        
        for agreement in agreements:
            agreement_number = agreement.get('agreement_number')
            
            if not agreement_number:
                continue
            
            # Check if already in campaign pool
            existing = supabase.table('campaign_pool') \
                .select('id') \
                .eq('agreement_number', agreement_number) \
                .eq('campaign_tag', campaign_tag) \
                .execute()
            
            if existing.data and len(existing.data) > 0:
                print(f"⏭️  {agreement_number} already queued, skipping")
                continue
            
            # Insert into campaign pool
            insert_data = {
                'agreement_number': agreement_number,
                'campaign_tag': campaign_tag,
                'status': 'queued'
            }
            
            supabase.table('campaign_pool').insert(insert_data).execute()
            queued_count += 1
            print(f"✅ Queued {agreement_number} for {campaign_tag}")
            
            # Random 5-20 second delay between queue items to look natural
            delay = random.randint(5, 20)
            time.sleep(delay)
        
        print(f"\n🎯 Summary: {queued_count} new agreement(s) queued for anniversary campaign")
    
    except Exception as e:
        print(f"❌ Error queuing agreements: {e}")


def main():
    """Main entry point for anniversary trigger job."""
    # Get current time in UK timezone
    tz = ZoneInfo("Europe/London")
    now = datetime.now(tz)
    
    # Random 0-20 min jitter so it doesn't look robotic
    jitter_minutes = random.randint(0, 20)
    jitter_seconds = jitter_minutes * 60
    
    print("=" * 60)
    print("  ANNIVERSARY TRIGGER - 12 Month Campaign")
    print("=" * 60)
    print(f"Scheduled time: {now.strftime('%Y-%m-%d %H:%M:%S %Z')}")
    print(f"Random jitter: {jitter_minutes} minutes")
    print(f"Actual run time: {(now + timedelta(minutes=jitter_minutes)).strftime('%Y-%m-%d %H:%M:%S %Z')}")
    
    if jitter_seconds > 0:
        print(f"⏳ Waiting {jitter_minutes} minute(s) before execution...\n")
        time.sleep(jitter_seconds)
    
    # Check if we're within the new-conversation window (10:15-11:45 UK time)
    now = datetime.now(tz)
    timestamp = now.strftime("%Y-%m-%d %H:%M:%S")
    print(f"Starting execution at: {timestamp}")
    
    if not (dt.time(10, 15) <= now.time() <= dt.time(11, 45)):
        print("⏰ Outside new-conversation window (10:15-11:45); skipping today.")
        print("=" * 60)
        sys.exit(0)
    
    print("✅ Within conversation window (10:15-11:45), proceeding...\n")
    
    # Find customers at 12-month anniversary
    anniversary_customers = find_anniversary_customers()
    
    # Queue them for anniversary campaign
    queue_for_campaign(anniversary_customers, campaign_tag='anniversary_12m')
    
    print("\n" + "=" * 60)
    print("  Anniversary trigger completed")
    print("=" * 60)


if __name__ == '__main__':
    main()