"""
Pinterest Automation Bot - Fixed Version
"""

import gradio as gr
import os
import logging
import tempfile
import shutil
import stat
from pathlib import Path
import datetime
import re

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Global Pinterest automation instance for session management
pinterest_bot = None

def get_pinterest_bot():
    """Get or create the global Pinterest bot instance"""
    global pinterest_bot
    if pinterest_bot is None:
        try:
            from pinterest_automation_portable import PortablePinterestAutomation
            pinterest_bot = PortablePinterestAutomation(headless=True, fast_typing=True)
            logger.info("Created new Pinterest bot instance")
        except Exception as e:
            logger.error(f"Failed to create Pinterest bot: {e}")
            return None
    return pinterest_bot

def cleanup_pinterest_bot():
    """Cleanup the global Pinterest bot instance"""
    global pinterest_bot
    if pinterest_bot is not None:
        try:
            pinterest_bot.quit()
            logger.info("Pinterest bot instance cleaned up")
        except Exception as e:
            logger.error(f"Error cleaning up Pinterest bot: {e}")
        finally:
            pinterest_bot = None

def reset_session():
    """Reset the Pinterest session"""
    cleanup_pinterest_bot()
    return "🔄 Session reset successfully! You can now login with different credentials or refresh the connection."

def ensure_executable_permissions():
    """Ensure Chrome binary and ChromeDriver have executable permissions"""
    try:
        # Define paths to executables
        chrome_binary = Path("chrome_portable/chrome")
        chromedriver_binary = Path("drivers/chromedriver")
        
        # Set executable permissions if files exist
        if chrome_binary.exists():
            current_permissions = chrome_binary.stat().st_mode
            chrome_binary.chmod(current_permissions | stat.S_IEXEC | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
            logger.info(f"Set executable permission for: {chrome_binary}")
        else:
            logger.warning(f"Chrome binary not found: {chrome_binary}")
            
        if chromedriver_binary.exists():
            current_permissions = chromedriver_binary.stat().st_mode
            chromedriver_binary.chmod(current_permissions | stat.S_IEXEC | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
            logger.info(f"Set executable permission for: {chromedriver_binary}")
        else:
            logger.warning(f"ChromeDriver not found: {chromedriver_binary}")
            
    except Exception as e:
        logger.error(f"Failed to set executable permissions: {str(e)}")

def upload_pin(email, password, image, title, description, board_name, link_url, headless):
    """Main function to upload a pin to Pinterest with session management"""
    
    # Input validation
    if not email or not password:
        return "❌ Please enter your Pinterest email and password"
    
    if not image:
        return "❌ Please upload an image"
    
    if not title or not description or not board_name:
        return "❌ Please fill in title, description, and board name"
    
    # Validate URL format if provided
    if link_url:
        # Simple URL validation
        url_pattern = re.compile(
            r'^https?://'  # http:// or https://
            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|'  # domain...
            r'localhost|'  # localhost...
            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'  # ...or ip
            r'(?::\d+)?'  # optional port
            r'(?:/?|[/?]\S+)$', re.IGNORECASE)
        
        if not url_pattern.match(link_url):
            return "❌ Please enter a valid URL (starting with http:// or https://)"
    
    # Create uploads directory if it doesn't exist
    uploads_dir = Path("uploads")
    uploads_dir.mkdir(exist_ok=True)
    
    # Generate unique filename with timestamp
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    image_extension = Path(image).suffix or '.jpg'
    stored_image_name = f"upload_{timestamp}{image_extension}"
    stored_image_path = uploads_dir / stored_image_name
    
    try:
        # Get or create Pinterest bot instance
        pinterest = get_pinterest_bot()
        if not pinterest:
            return "❌ Failed to initialize Pinterest bot"
        
        # Check if we need to setup driver
        if not hasattr(pinterest, 'driver') or not pinterest.driver:
            logger.info("Setting up Chrome driver...")
            if not pinterest._setup_driver():
                return "❌ Failed to setup Chrome driver. Please try again."
        
        # Check if we need to login or if user changed
        if not pinterest.is_logged_in or pinterest.current_email != email:
            logger.info(f"Logging in as {email}...")
            if not pinterest.login(email, password):
                return "❌ Login failed. Please check your credentials."
        else:
            logger.info(f"Already logged in as {email}, continuing with existing session")
        
        try:
            # Ensure Chrome and ChromeDriver have executable permissions
            ensure_executable_permissions()
            
            # Store image in uploads directory
            shutil.copy2(image, stored_image_path)
            logger.info(f"Image stored at: {stored_image_path}")
            
            # Navigate to pin creation page (reuse existing session)
            logger.info("Navigating to pin creation page...")
            pinterest.driver.get("https://www.pinterest.com/pin-builder/")
            pinterest._human_delay(3, 5)
            
            # Create temp directory for processing
            temp_dir = tempfile.mkdtemp()
            temp_image_path = os.path.join(temp_dir, "uploaded_image.jpg")
            shutil.copy2(image, temp_image_path)
            
            # Upload image
            if not pinterest.upload_image(temp_image_path):
                return "❌ Failed to upload image."
            
            # Set pin details
            if not pinterest.set_title(title):
                return "❌ Failed to set title."
            
            if not pinterest.set_description(description):
                return "❌ Failed to set description."
            
            # Set optional link (only if valid URL provided)
            if link_url and link_url.strip():
                if not pinterest.set_link(link_url.strip()):
                    return "❌ Failed to set link. Please check the URL format."
            
            # Select board
            if not pinterest.select_board(board_name):
                return "❌ Failed to select board. Make sure it exists in your Pinterest."
            
            # Publish pin
            if not pinterest.publish_pin():
                return "❌ Failed to publish pin. Please check for validation errors."
            
            # Cleanup temp directory
            shutil.rmtree(temp_dir)
            
            # If successful, clean up stored image
            if stored_image_path.exists():
                stored_image_path.unlink()
                logger.info(f"Cleaned up stored image: {stored_image_path}")
            
            logger.info("Pin uploaded successfully! Bot session maintained for next upload.")
            return f"✅ Success! Pin '{title}' uploaded to board '{board_name}'. Session maintained for faster future uploads."
            
        except Exception as inner_e:
            # If there's an error, keep the stored image for debugging
            logger.error(f"Upload failed, keeping image for debugging: {stored_image_path}")
            return f"❌ Upload failed: {str(inner_e)}. Image saved at {stored_image_path} for debugging."
    
    except ImportError as e:
        return f"❌ Setup error: {str(e)}. Chrome setup is missing."
    except Exception as e:
        logger.error(f"Error: {str(e)}")
        return f"❌ Error: {str(e)}"

# Simple interface that should work with Gradio 4.40.0
with gr.Blocks(title="Pinterest Automation Bot") as app:
    
    gr.Markdown("# 📌 Pinterest Automation Bot")
    gr.Markdown("Upload pins to Pinterest automatically with advanced automation.")
    
    # Status indicator
    with gr.Row():
        status_text = gr.Markdown("🟢 **Status**: Ready to upload pins!")
    
    # Login section
    gr.Markdown("### 🔐 Pinterest Login")
    email = gr.Textbox(label="Email", placeholder="your-email@example.com")
    password = gr.Textbox(label="Password", type="password")
    
    # Pin details section
    gr.Markdown("### 📝 Pin Details")
    image = gr.File(label="Image")
    title = gr.Textbox(label="Title", placeholder="Enter pin title...")
    description = gr.Textbox(label="Description", lines=3, placeholder="Enter pin description...")
    board_name = gr.Textbox(label="Board Name", placeholder="Enter existing board name...")
    link_url = gr.Textbox(label="Link (Optional)", placeholder="https://example.com")
    
    # Options
    gr.Markdown("### ⚙️ Options")
    headless = gr.Checkbox(label="Run in headless mode (recommended)", value=True)
    
    # Submit button
    submit_btn = gr.Button("🚀 Upload Pin to Pinterest", variant="primary")
    
    # Session reset button
    reset_btn = gr.Button("🔄 Reset Session", variant="secondary")
    
    # Output
    result = gr.Textbox(label="Result", lines=3, interactive=False)

    # Event handlers
    submit_btn.click(
        upload_pin,
        inputs=[email, password, image, title, description, board_name, link_url, headless],
        outputs=result
    )
    
    reset_btn.click(
        reset_session,
        inputs=[],
        outputs=result
    )
    
    gr.Markdown("""
    ### 📖 Instructions
    1. Enter your Pinterest credentials
    2. Upload an image (PNG, JPG, GIF, WebP)
    3. Fill in pin details (title, description, board name)
    4. Optionally add a destination link
    5. Click "Upload Pin to Pinterest"
    
    **Note**: Board must already exist in your Pinterest account.
    
    ### 🔄 Session Management
    - The bot maintains your login session between uploads for faster operation
    - Use "Reset Session" to logout and start fresh (useful when switching accounts or if errors occur)
    - Session is automatically maintained until you reset or restart the application
    """)

if __name__ == "__main__":
    try:
        logger.info("=== Starting Pinterest Bot Application ===")
        
        # Ensure executable permissions are set
        logger.info("Setting executable permissions...")
        ensure_executable_permissions()
        logger.info("Executable permissions set successfully")
        
        # Check if running on Hugging Face Spaces
        is_spaces = os.getenv('SPACE_ID') is not None
        logger.info(f"Running on Hugging Face Spaces: {is_spaces}")
        
        # For HF Spaces, start the app quickly and do heavy initialization later
        if is_spaces:
            logger.info("Quick launch for HF Spaces...")
            app.queue()  # Enable queuing for better performance
            app.launch(
                server_name="0.0.0.0",
                server_port=7860,
                share=False,
                show_error=True,
                quiet=False,
                favicon_path=None,
                enable_monitoring=False
            )
        else:
            # For local development, do full initialization
            logger.info("Full initialization for local development...")
            
            # Test imports to make sure everything is working
            logger.info("Testing module imports...")
            try:
                from pinterest_automation_portable import PortablePinterestAutomation
                logger.info("✅ Pinterest automation module imported successfully")
            except Exception as e:
                logger.error(f"❌ Failed to import Pinterest automation module: {e}")
            
            try:
                from chrome_wrapper import get_chrome_manager
                logger.info("✅ Chrome wrapper imported successfully")
                
                # Test chrome manager creation (but don't start browser)
                chrome_manager = get_chrome_manager()
                config_info = chrome_manager.get_config_info()
                logger.info(f"✅ Chrome setup verified: {config_info['chrome_binary']}")
            except Exception as e:
                logger.error(f"❌ Failed to setup Chrome wrapper: {e}")
            
            logger.info("Launching Gradio app...")
            app.launch(
                server_name="0.0.0.0",
                server_port=7861,
                share=True,
                show_error=True,
                quiet=False
            )
        
    except Exception as e:
        logger.error(f"Failed to start application: {e}")
        raise