from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import undetected_chromedriver as uc

def setup_driver():
    options = uc.ChromeOptions()
    
    # Stealth configuration
    options.add_argument('--disable-blink-features=AutomationControlled')
    options.add_experimental_option("excludeSwitches", ["enable-automation"])
    options.add_experimental_option('useAutomationExtension', False)
    
    # Realistic viewport
    options.add_argument('--window-size=1920,1080')
    
    # User agent rotation
    options.add_argument('user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36')
    
    driver = uc.Chrome(options=options)
    
    # Inject anti-detection scripts
    driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
        'source': '''
            Object.defineProperty(navigator, 'webdriver', {
                get: () => undefined
            })
        '''
    })
    
    return driver

def detect_captcha_type(driver):
    """
    Identify which captcha system Twitter is using
    """
    try:
        # Check for funcaptcha (ArkoseLabs)
        funcaptcha_frame = driver.find_elements(By.CSS_SELECTOR, 
            'iframe[src*="client-api.arkoselabs.com"]')
        if funcaptcha_frame:
            return 'funcaptcha'
        
        # Check for reCAPTCHA
        recaptcha_frame = driver.find_elements(By.CSS_SELECTOR,
            'iframe[src*="google.com/recaptcha"]')
        if recaptcha_frame:
            return 'recaptcha_v2'
        
        # Check for hCaptcha
        hcaptcha_frame = driver.find_elements(By.CSS_SELECTOR,
            'iframe[src*="hcaptcha.com"]')
        if hcaptcha_frame:
            return 'hcaptcha'
            
        return None
        
    except Exception as e:
        print(f"Error detecting captcha: {e}")
        return None

import requests
import time

class CaptchaSolver:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "http://2captcha.com"
    
    def solve_funcaptcha(self, public_key, page_url):
        """
        Solve funcaptcha using 2captcha API
        """
        # Submit captcha
        submit_url = f"{self.base_url}/in.php"
        data = {
            'key': self.api_key,
            'method': 'funcaptcha',
            'publickey': public_key,
            'pageurl': page_url,
            'json': 1
        }
        
        response = requests.post(submit_url, data=data)
        result = response.json()
        
        if result['status'] != 1:
            raise Exception(f"Failed to submit captcha: {result}")
        
        task_id = result['request']
        
        # Poll for solution
        get_url = f"{self.base_url}/res.php"
        for _ in range(60):  # Try for 60 seconds
            time.sleep(2)
            
            response = requests.get(get_url, params={
                'key': self.api_key,
                'action': 'get',
                'id': task_id,
                'json': 1
            })
            
            result = response.json()
            
            if result['status'] == 1:
                return result['request']
            
            if result['request'] != 'CAPCHA_NOT_READY':
                raise Exception(f"Captcha solving failed: {result}")
        
        raise Exception("Captcha solving timeout")
    
    def inject_solution(self, driver, token):
        """
        Inject solved captcha token into page
        """
        script = f"""
            document.querySelector('[name="h-captcha-response"]').value = '{token}';
            document.querySelector('[name="g-recaptcha-response"]').value = '{token}';
        """
        driver.execute_script(script)

import random
from time import sleep

class HumanBehavior:
    @staticmethod
    def random_delay(min_seconds=1, max_seconds=3):
        """
        Add human-like delays between actions
        """
        sleep(random.uniform(min_seconds, max_seconds))
    
    @staticmethod
    def type_like_human(element, text):
        """
        Type text with random delays between keystrokes
        """
        for char in text:
            element.send_keys(char)
            sleep(random.uniform(0.05, 0.15))
    
    @staticmethod
    def move_mouse_randomly(driver):
        """
        Simulate random mouse movements
        """
        from selenium.webdriver.common.action_chains import ActionChains
        
        action = ActionChains(driver)
        for _ in range(random.randint(2, 5)):
            x_offset = random.randint(-100, 100)
            y_offset = random.randint(-100, 100)
            action.move_by_offset(x_offset, y_offset)
            action.perform()
            sleep(random.uniform(0.1, 0.3))

class ProxyManager:
    def __init__(self, proxy_list):
        self.proxies = proxy_list
        self.current_index = 0
        self.failed_proxies = set()
    
    def get_next_proxy(self):
        """
        Rotate through working proxies
        """
        attempts = 0
        while attempts < len(self.proxies):
            proxy = self.proxies[self.current_index]
            self.current_index = (self.current_index + 1) % len(self.proxies)
            
            if proxy not in self.failed_proxies:
                return proxy
            
            attempts += 1
        
        raise Exception("No working proxies available")
    
    def mark_failed(self, proxy):
        self.failed_proxies.add(proxy)
    
    def configure_selenium(self, options, proxy):
        """
        Configure Selenium with proxy
        """
        options.add_argument(f'--proxy-server={proxy}')
        return options

class TwitterAutomation:
    def __init__(self, username, password, captcha_api_key):
        self.username = username
        self.password = password
        self.solver = CaptchaSolver(captcha_api_key)
        self.driver = setup_driver()
    
    def login(self):
        """
        Automated Twitter login with captcha handling
        """
        try:
            # Navigate to login page
            self.driver.get('https://twitter.com/i/flow/login')
            
            HumanBehavior.random_delay(2, 4)
            
            # Enter username
            username_input = WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.NAME, 'text'))
            )
            HumanBehavior.type_like_human(username_input, self.username)
            
            # Click Next
            next_button = self.driver.find_element(By.XPATH, 
                '//span[text()="Next"]')
            next_button.click()
            
            HumanBehavior.random_delay(2, 3)
            
            # Enter password
            password_input = WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.NAME, 'password'))
            )
            HumanBehavior.type_like_human(password_input, self.password)
            
            # Check for captcha before clicking login
            captcha_type = detect_captcha_type(self.driver)
            
            if captcha_type:
                print(f"Captcha detected: {captcha_type}")
                self.handle_captcha(captcha_type)
            
            # Click Login
            login_button = self.driver.find_element(By.XPATH,
                '//span[text()="Log in"]')
            login_button.click()
            
            HumanBehavior.random_delay(3, 5)
            
            # Verify login success
            if self.is_logged_in():
                print("Login successful!")
                return True
            else:
                print("Login failed")
                return False
                
        except Exception as e:
            print(f"Login error: {e}")
            return False
    
    def handle_captcha(self, captcha_type):
        """
        Handle different captcha types
        """
        if captcha_type == 'funcaptcha':
            public_key = self.extract_funcaptcha_key()
            token = self.solver.solve_funcaptcha(
                public_key, 
                self.driver.current_url
            )
            self.solver.inject_solution(self.driver, token)
            
        elif captcha_type == 'recaptcha_v2':
            site_key = self.extract_recaptcha_key()
            token = self.solver.solve_recaptcha(
                site_key,
                self.driver.current_url
            )
            self.solver.inject_solution(self.driver, token)
    
    def extract_funcaptcha_key(self):
        """
        Extract funcaptcha public key from page
        """
        iframe = self.driver.find_element(By.CSS_SELECTOR,
            'iframe[src*="arkoselabs.com"]')
        src = iframe.get_attribute('src')
        
        # Parse public key from iframe src
        import re
        match = re.search(r'pk=([A-F0-9-]+)', src)
        if match:
            return match.group(1)
        
        raise Exception("Could not find funcaptcha public key")
    
    def is_logged_in(self):
        """
        Check if login was successful
        """
        try:
            # Check for home timeline
            WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.XPATH, 
                    '//a[@href="/home"]'))
            )
            return True
        except:
            return False

from selenium.webdriver.common.desired_capabilities import DesiredCapabilities

def setup_network_interception(driver):
    """
    Monitor network requests to understand captcha flow
    """
    caps = DesiredCapabilities.CHROME
    caps['goog:loggingPrefs'] = {'performance': 'ALL'}
    
    # Analyze network logs
    logs = driver.get_log('performance')
    
    for entry in logs:
        log = json.loads(entry['message'])['message']
        
        # Look for captcha-related requests
        if 'Network.responseReceived' in log['method']:
            url = log['params']['response']['url']
            
            if 'arkoselabs.com' in url or 'funcaptcha' in url:
                print(f"Captcha request detected: {url}")
                # Extract tokens, keys, etc.

import pickle

class SessionManager:
    def __init__(self, session_file='twitter_session.pkl'):
        self.session_file = session_file
    
    def save_cookies(self, driver):
        """
        Save browser cookies for reuse
        """
        cookies = driver.get_cookies()
        with open(self.session_file, 'wb') as f:
            pickle.dump(cookies, f)
        print(f"Saved {len(cookies)} cookies")
    
    def load_cookies(self, driver):
        """
        Load saved cookies to skip login
        """
        try:
            with open(self.session_file, 'rb') as f:
                cookies = pickle.load(f)
            
            driver.get('https://twitter.com')
            
            for cookie in cookies:
                driver.add_cookie(cookie)
            
            driver.refresh()
            print(f"Loaded {len(cookies)} cookies")
            return True
            
        except FileNotFoundError:
            print("No saved session found")
            return False

// Inject into page to mask canvas fingerprinting
const script = `
    const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
    const originalToBlob = HTMLCanvasElement.prototype.toBlob;
    const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
    
    // Add noise to canvas fingerprinting
    const addNoise = (imageData) => {
        for (let i = 0; i < imageData.data.length; i += 4) {
            imageData.data[i] += Math.floor(Math.random() * 10) - 5;
        }
        return imageData;
    };
    
    CanvasRenderingContext2D.prototype.getImageData = function() {
        const imageData = originalGetImageData.apply(this, arguments);
        return addNoise(imageData);
    };
`;

driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': script
})

def inject_webgl_protection(driver):
    script = """
        const getParameter = WebGLRenderingContext.prototype.getParameter;
        WebGLRenderingContext.prototype.getParameter = function(parameter) {
            // Randomize WebGL vendor and renderer
            if (parameter === 37445) {
                return 'Intel Inc.';
            }
            if (parameter === 37446) {
                return 'Intel Iris OpenGL Engine';
            }
            return getParameter.apply(this, arguments);
        };
    """
    driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
        'source': script
    })

import capsolver

capsolver.api_key = "YOUR_API_KEY"

def solve_funcaptcha(public_key, page_url, blob_data=None):
    solution = capsolver.solve({
        "type": "FunCaptchaTaskProxyLess",
        "websitePublicKey": public_key,
        "websiteURL": page_url,
        "data": blob_data  # Optional blob parameter
    })
    
    return solution['token']

# Usage
public_key = "0152B4EB-D2DC-460A-89A1-629838B529C9"  # Twitter's key
page_url = "https://twitter.com/i/flow/login"

token = solve_funcaptcha(public_key, page_url)
print(f"Captcha solved: {token[:50]}...")

def handle_twitter_captcha(driver, solver):
    """
    Complete captcha handling flow
    """
    # Wait for captcha iframe
    WebDriverWait(driver, 20).until(
        EC.frame_to_be_available_and_switch_to_it((
            By.CSS_SELECTOR, 
            'iframe[src*="arkoselabs.com"]'
        ))
    )
    
    # Extract data-public-key
    public_key = driver.execute_script("""
        const iframe = document.querySelector('iframe[src*="arkoselabs.com"]');
        return iframe.getAttribute('data-public-key');
    """)
    
    # Switch back to main frame
    driver.switch_to.default_content()
    
    # Solve captcha
    token = solver.solve_funcaptcha(public_key, driver.current_url)
    
    # Inject solution
    driver.execute_script(f"""
        window.arkoseCallback('{token}');
    """)
    
    return token

def setup_undetectable_chrome():
    options = uc.ChromeOptions()
    
    # Disable headless mode detection
    options.add_argument('--disable-blink-features=AutomationControlled')
    
    # Hide webdriver property
    options.add_experimental_option("excludeSwitches", ["enable-automation"])
    options.add_experimental_option('useAutomationExtension', False)
    
    # Realistic browser behavior
    prefs = {
        "credentials_enable_service": False,
        "profile.password_manager_enabled": False,
        "profile.default_content_setting_values.notifications": 2
    }
    options.add_experimental_option("prefs", prefs)
    
    driver = uc.Chrome(options=options, version_main=120)
    
    # Additional stealth scripts
    stealth_js = """
        // Override navigator.webdriver
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
        
        // Override permissions
        const originalQuery = window.navigator.permissions.query;
        window.navigator.permissions.query = (parameters) => (
            parameters.name === 'notifications' ?
                Promise.resolve({ state: Notification.permission }) :
                originalQuery(parameters)
        );
        
        // Override plugins length
        Object.defineProperty(navigator, 'plugins', {
            get: () => [1, 2, 3, 4, 5]
        });
    """
    
    driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
        'source': stealth_js
    })
    
    return driver

from datetime import datetime, timedelta
import redis

class RateLimiter:
    def __init__(self, redis_client):
        self.redis = redis_client
    
    def check_limit(self, account_id, max_actions=50, period_hours=24):
        """
        Implement sliding window rate limiting
        """
        key = f"twitter:ratelimit:{account_id}"
        now = datetime.now().timestamp()
        window_start = now - (period_hours * 3600)
        
        # Remove old entries
        self.redis.zremrangebyscore(key, 0, window_start)
        
        # Count recent actions
        action_count = self.redis.zcard(key)
        
        if action_count >= max_actions:
            # Get oldest action time
            oldest = self.redis.zrange(key, 0, 0, withscores=True)
            if oldest:
                wait_until = oldest[0][1] + (period_hours * 3600)
                wait_seconds = int(wait_until - now)
                raise Exception(f"Rate limit exceeded. Wait {wait_seconds}s")
        
        # Add current action
        self.redis.zadd(key, {now: now})
        self.redis.expire(key, period_hours * 3600)
        
        return True

# Usage
limiter = RateLimiter(redis.Redis())

try:
    limiter.check_limit('account_123', max_actions=50, period_hours=24)
    # Proceed with action
except Exception as e:
    print(f"Rate limited: {e}")

from functools import wraps
import time

def retry_on_captcha(max_retries=3, backoff_factor=2):
    """
    Decorator for retrying operations when captcha appears
    """
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except CaptchaException as e:
                    if attempt == max_retries - 1:
                        raise
                    
                    wait_time = backoff_factor ** attempt
                    print(f"Captcha encountered. Retry {attempt + 1}/{max_retries} after {wait_time}s")
                    time.sleep(wait_time)
                    
                    # Switch to different session/proxy
                    if 'driver' in kwargs:
                        kwargs['driver'] = setup_driver()
            
            raise Exception(f"Failed after {max_retries} retries")
        
        return wrapper
    return decorator

@retry_on_captcha(max_retries=3)
def post_tweet(driver, content):
    # Implementation
    pass

import logging
from datetime import datetime

class AutomationLogger:
    def __init__(self, log_file='twitter_automation.log'):
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler(log_file),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def log_action(self, action, account, success, details=None):
        """
        Log automation actions for analysis
        """
        log_data = {
            'timestamp': datetime.now().isoformat(),
            'action': action,
            'account': account,
            'success': success,
            'details': details
        }
        
        if success:
            self.logger.info(f"Action succeeded: {log_data}")
        else:
            self.logger.error(f"Action failed: {log_data}")
    
    def log_captcha_encounter(self, captcha_type, solved):
        """
        Track captcha statistics
        """
        self.logger.warning(f"Captcha encountered: {captcha_type}, Solved: {solved}")

class TwitterAutomationFramework:
    def __init__(self, config):
        self.config = config
        self.proxy_manager = ProxyManager(config['proxies'])
        self.session_manager = SessionManager()
        self.solver = CaptchaSolver(config['captcha_api_key'])
        self.rate_limiter = RateLimiter(redis.Redis())
        self.logger = AutomationLogger()
    
    def execute_action(self, account_id, action_func, *args, **kwargs):
        """
        Execute action with full error handling and logging
        """
        try:
            # Check rate limit
            self.rate_limiter.check_limit(account_id)
            
            # Setup driver with proxy
            proxy = self.proxy_manager.get_next_proxy()
            driver = self.setup_driver_with_proxy(proxy)
            
            # Try to use existing session
            if not self.session_manager.load_cookies(driver):
                # New login required
                if not self.login(driver, account_id):
                    raise Exception("Login failed")
                self.session_manager.save_cookies(driver)
            
            # Execute action
            result = action_func(driver, *args, **kwargs)
            
            self.logger.log_action(
                action_func.__name__,
                account_id,
                True,
                result
            )
            
            return result
            
        except CaptchaException as e:
            self.logger.log_captcha_encounter(e.captcha_type, False)
            raise
            
        except Exception as e:
            self.logger.log_action(
                action_func.__name__,
                account_id,
                False,
                str(e)
            )
            raise
            
        finally:
            if 'driver' in locals():
                driver.quit()

import tweepy

# Official API approach
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)

# Post tweet via official API
api.update_status("Hello World!")