app/ads/google_ads.py

"""

Google Ads Integration

Handles displaying Google AdSense ads and tracking ad impressions/clicks

"""
import os
import uuid
import logging
import json
import time
from typing import Dict, Any, Optional, List
from datetime import datetime

# Setup logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("google_ads")

class GoogleAdsManager:
    """Manages Google AdSense integration and tracking"""
    
    def __init__(self, publisher_id: Optional[str] = None, config_file: str = None):
        """Initialize Google Ads Manager"""
        self.publisher_id = publisher_id or os.getenv("GOOGLE_ADSENSE_PUBLISHER_ID", "")
        self.config_file = config_file or os.path.join(os.path.dirname(__file__), "ads_config.json")
        
        # Load ad units configuration
        self.ad_units = self._load_ad_units()
        
        # Track impressions and clicks
        self.impressions_file = os.path.join(os.path.dirname(__file__), "impressions.json")
        self.clicks_file = os.path.join(os.path.dirname(__file__), "clicks.json")
        
        # Create tracking files if they don't exist
        self._initialize_tracking_files()
    
    def _load_ad_units(self) -> Dict[str, Any]:
        """Load ad units configuration"""
        default_ad_units = {
            "sidebar": {
                "ad_unit_id": "1234567890",
                "ad_format": "display",
                "width": 300,
                "height": 250,
                "slot": "sidebar-ad",
                "enabled": True
            },
            "footer": {
                "ad_unit_id": "0987654321",
                "ad_format": "display",
                "width": 728,
                "height": 90,
                "slot": "footer-ad",
                "enabled": True
            },
            "reward_video": {
                "ad_unit_id": "5678901234",
                "ad_format": "video",
                "slot": "reward-video-ad",
                "enabled": True,
                "reward_credits": 10
            }
        }
        
        # Create config file with default values if it doesn't exist
        if not os.path.exists(self.config_file):
            os.makedirs(os.path.dirname(self.config_file), exist_ok=True)
            with open(self.config_file, "w") as f:
                json.dump({"publisher_id": self.publisher_id, "ad_units": default_ad_units}, f, indent=2)
            return default_ad_units
        
        # Load config from file
        try:
            with open(self.config_file, "r") as f:
                config = json.load(f)
                
                # Update publisher ID if it was set in the config file
                if config.get("publisher_id"):
                    self.publisher_id = config["publisher_id"]
                
                return config.get("ad_units", default_ad_units)
        except Exception as e:
            logger.error(f"Error loading ad units config: {e}")
            return default_ad_units
    
    def _initialize_tracking_files(self):
        """Initialize tracking files if they don't exist"""
        os.makedirs(os.path.dirname(self.impressions_file), exist_ok=True)
        
        if not os.path.exists(self.impressions_file):
            with open(self.impressions_file, "w") as f:
                json.dump([], f)
        
        if not os.path.exists(self.clicks_file):
            with open(self.clicks_file, "w") as f:
                json.dump([], f)
    
    def get_ad_code(self, ad_position: str) -> Dict[str, Any]:
        """

        Get HTML/JS code for displaying an ad at the specified position

        Returns both the ad code and metadata about the ad

        """
        if not self.publisher_id:
            logger.warning("No Google AdSense publisher ID configured")
            return {"success": False, "error": "No publisher ID configured"}
        
        # Get ad unit configuration
        ad_unit = self.ad_units.get(ad_position)
        if not ad_unit:
            logger.error(f"Ad position '{ad_position}' not configured")
            return {"success": False, "error": f"Ad position '{ad_position}' not found"}
        
        if not ad_unit.get("enabled", True):
            logger.info(f"Ad unit '{ad_position}' is disabled")
            return {"success": False, "error": "Ad unit is disabled"}
        
        # Generate HTML/JS code for the ad
        ad_format = ad_unit.get("ad_format", "display")
        ad_unit_id = ad_unit.get("ad_unit_id", "")
        ad_slot = ad_unit.get("slot", f"{ad_position}-ad")
        
        if ad_format == "display":
            width = ad_unit.get("width", 300)
            height = ad_unit.get("height", 250)
            
            ad_code = f"""

            <ins class="adsbygoogle"

                 style="display:inline-block;width:{width}px;height:{height}px"

                 data-ad-client="ca-pub-{self.publisher_id}"

                 data-ad-slot="{ad_unit_id}"></ins>

            <script>

                 (adsbygoogle = window.adsbygoogle || []).push({{}});

            </script>

            """
        elif ad_format == "video":
            ad_code = f"""

            <div id="{ad_slot}" class="reward-ad-container">

                <div class="reward-ad-placeholder">

                    <p>Watch a video to earn {ad_unit.get('reward_credits', 5)} credits</p>

                    <button class="watch-ad-btn" onclick="loadRewardAd('{ad_slot}', '{ad_unit_id}', {ad_unit.get('reward_credits', 5)})">Watch Now</button>

                </div>

            </div>

            """
        else:
            logger.error(f"Unsupported ad format: {ad_format}")
            return {"success": False, "error": f"Unsupported ad format: {ad_format}"}
        
        # Generate a unique ID for tracking this ad impression
        impression_id = str(uuid.uuid4())
        
        # Record the impression for tracking
        self._record_impression(impression_id, ad_position, ad_unit_id)
        
        return {
            "success": True,
            "ad_code": ad_code,
            "impression_id": impression_id,
            "ad_position": ad_position,
            "ad_format": ad_format,
            "reward_credits": ad_unit.get("reward_credits", 0) if ad_format == "video" else 0
        }
    
    def _record_impression(self, impression_id: str, ad_position: str, ad_unit_id: str):
        """Record an ad impression for tracking"""
        try:
            # Load existing impressions
            with open(self.impressions_file, "r") as f:
                impressions = json.load(f)
            
            # Add new impression
            impressions.append({
                "id": impression_id,
                "timestamp": datetime.now().isoformat(),
                "ad_position": ad_position,
                "ad_unit_id": ad_unit_id
            })
            
            # Save updated impressions
            with open(self.impressions_file, "w") as f:
                json.dump(impressions, f, indent=2)
                
        except Exception as e:
            logger.error(f"Error recording ad impression: {e}")
    
    def record_ad_click(self, impression_id: str, user_id: Optional[str] = None) -> bool:
        """Record an ad click for tracking"""
        try:
            # Load existing clicks
            with open(self.clicks_file, "r") as f:
                clicks = json.load(f)
            
            # Add new click
            clicks.append({
                "impression_id": impression_id,
                "user_id": user_id,
                "timestamp": datetime.now().isoformat()
            })
            
            # Save updated clicks
            with open(self.clicks_file, "w") as f:
                json.dump(clicks, f, indent=2)
                
            return True
                
        except Exception as e:
            logger.error(f"Error recording ad click: {e}")
            return False
    
    def record_reward_ad_completion(self, impression_id: str, user_id: str) -> Dict[str, Any]:
        """

        Record completion of a reward ad and return reward information

        

        Args:

            impression_id: The unique ID of the ad impression

            user_id: The user ID to reward

            

        Returns:

            Dictionary with reward information and success status

        """
        try:
            # Find the impression to determine the ad unit
            with open(self.impressions_file, "r") as f:
                impressions = json.load(f)
            
            # Find the impression with matching ID
            impression = next((imp for imp in impressions if imp.get("id") == impression_id), None)
            if not impression:
                logger.error(f"Impression ID {impression_id} not found")
                return {
                    "success": False, 
                    "error": "Invalid impression ID"
                }
            
            # Get the ad position from the impression
            ad_position = impression.get("ad_position")
            ad_unit = self.ad_units.get(ad_position)
            
            if not ad_unit:
                logger.error(f"Ad unit for position {ad_position} not found")
                return {
                    "success": False,
                    "error": "Ad unit not found"
                }
            
            # Get the reward amount
            reward_credits = ad_unit.get("reward_credits", 0)
            
            # Record the ad completion (we could store this in a separate file)
            self.record_ad_click(impression_id, user_id)
            
            return {
                "success": True,
                "reward_credits": reward_credits,
                "user_id": user_id,
                "impression_id": impression_id,
                "timestamp": datetime.now().isoformat()
            }
            
        except Exception as e:
            logger.error(f"Error processing reward ad completion: {e}")
            return {
                "success": False,
                "error": str(e)
            }
    
    def get_html_header_code(self) -> str:
        """Get the HTML code to include in the page header for AdSense"""
        if not self.publisher_id:
            return ""
            
        return f"""

        <script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-{self.publisher_id}"

             crossorigin="anonymous"></script>

        """
    
    def get_reward_ad_js(self) -> str:
        """Get the JavaScript code for handling reward ads"""
        return """

        <script>

        let rewardAdLoaded = false;

        let adEventListenersAdded = false;

        let currentAdSlot = null;

        let rewardAmount = 0;

        

        function loadRewardAd(adSlot, adUnitId, credits) {

            currentAdSlot = adSlot;

            rewardAmount = credits;

            

            // Show loading indicator

            document.getElementById(adSlot).innerHTML = '<div class="loading-ad">Loading ad, please wait...</div>';

            

            // Create a new ad container

            const adContainer = document.createElement('div');

            adContainer.id = adSlot + '-container';

            document.getElementById(adSlot).appendChild(adContainer);

            

            // Load the Google ad

            const adManager = new google.ads.AdManager(adContainer);

            

            // Set up the ad

            adManager.setAdUnitPath(`/ca-pub-${publisherId}/${adUnitId}`);

            adManager.setAdSize([300, 250]);

            

            // Add event listeners

            if (!adEventListenersAdded) {

                adManager.addEventListener('loaded', onAdLoaded);

                adManager.addEventListener('error', onAdError);

                adManager.addEventListener('completed', onAdCompleted);

                adEventListenersAdded = true;

            }

            

            // Load the ad

            adManager.load();

        }

        

        function onAdLoaded() {

            rewardAdLoaded = true;

            document.getElementById(currentAdSlot).querySelector('.loading-ad').style.display = 'none';

        }

        

        function onAdError(error) {

            document.getElementById(currentAdSlot).innerHTML = 

                `<div class="ad-error">Error loading ad: ${error.message}. Please try again later.</div>`;

        }

        

        function onAdCompleted() {

            // Send a request to the server to record the completion and reward the user

            fetch('/api/ads/reward', {

                method: 'POST',

                headers: {

                    'Content-Type': 'application/json'

                },

                body: JSON.stringify({

                    impression_id: currentImpressionId,

                    completed: true

                })

            })

            .then(response => response.json())

            .then(data => {

                if (data.success) {

                    // Show success message

                    document.getElementById(currentAdSlot).innerHTML = 

                        `<div class="reward-success">Congratulations! You earned ${rewardAmount} credits.</div>`;

                    

                    // Update user credits display if available

                    const creditsDisplay = document.getElementById('user-credits');

                    if (creditsDisplay) {

                        const currentCredits = parseInt(creditsDisplay.innerText, 10);

                        creditsDisplay.innerText = currentCredits + rewardAmount;

                    }

                } else {

                    document.getElementById(currentAdSlot).innerHTML = 

                        `<div class="reward-error">Error: ${data.error}</div>`;

                }

            })

            .catch(error => {

                document.getElementById(currentAdSlot).innerHTML = 

                    `<div class="reward-error">Error: Unable to process reward. Please try again.</div>`;

            });

        }

        </script>

        """

# Example usage
if __name__ == "__main__":
    # Initialize the ads manager
    ads_manager = GoogleAdsManager()
    
    # Get ad code for the sidebar
    sidebar_ad = ads_manager.get_ad_code("sidebar")
    print(f"Sidebar ad success: {sidebar_ad['success']}")
    
    if sidebar_ad['success']:
        print(f"Impression ID: {sidebar_ad['impression_id']}")
        
    # Get the header code for AdSense
    header_code = ads_manager.get_html_header_code()
    print(f"Header code length: {len(header_code)}")