from flask import Flask, render_template, request, jsonify, redirect, url_for
import aiohttp
import asyncio
from bs4 import BeautifulSoup
import random
import string
import json
import threading
import os
import time
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor

app = Flask(__name__)

# Configuration globale
config = {
    'base_url': "https://ivoire-startup-tracker-edithbrou.replit.app",
    'accounts_file': "accounts_data.json",
    'is_running': False,
    'batch_size': 10,  # Nombre de requêtes parallèles
    'progress': {
        'total': 0,
        'current': 0,
        'success': 0,
        'failed': 0,
        'last_username': '',
        'last_status': '',
        'start_time': None,
        'end_time': None
    }
}

# Fonction pour générer un nom d'utilisateur aléatoire
def generate_random_username(min_length=8, max_length=12):
    """Génère un nom d'utilisateur aléatoire d'une longueur raisonnable"""
    length = random.randint(min_length, max_length)
    return ''.join(random.choice(string.ascii_lowercase) for _ in range(length))

# Fonction pour générer une adresse email aléatoire
def generate_random_email():
    """Génère une adresse email aléatoire"""
    username = ''.join(random.choice(string.ascii_lowercase) for _ in range(12))
    domains = ["gmail.com", "yahoo.com", "outlook.com", "example.com"]
    return f"{username}@{random.choice(domains)}"

# Fonction pour générer un mot de passe aléatoire
def generate_random_password(length=10):
    """Génère un mot de passe aléatoire avec un mélange de caractères"""
    chars = string.ascii_letters + string.digits + "!@#$%^&*()-_=+"  # Éviter certains caractères spéciaux qui pourraient causer des problèmes
    return ''.join(random.choice(chars) for _ in range(length))

# Fonction asynchrone pour créer un compte
async def create_account_async(session, is_startup_rep=False):
    """Crée un compte sur le site web de manière asynchrone"""
    register_url = f"{config['base_url']}/register"
    
    try:
        # Première requête pour récupérer le token CSRF
        async with session.get(register_url, timeout=10) as response:
            if response.status != 200:
                return {'success': False, 'error': f"Erreur lors de l'accès à la page: {response.status}"}
            
            html = await response.text()
            
            # Extraire le token CSRF
            soup = BeautifulSoup(html, 'html.parser')
            csrf_token_input = soup.find('input', {'id': 'csrf_token'})
            
            if not csrf_token_input:
                return {'success': False, 'error': "Impossible de trouver le token CSRF"}
                
            csrf_token = csrf_token_input.get('value')
            
            # Générer des informations de compte aléatoires
            username = generate_random_username()
            email = generate_random_email()
            password = generate_random_password()
            
            # Préparer les données du formulaire
            form_data = {
                'csrf_token': csrf_token,
                'username': username,
                'email': email,
                'password': password,
                'confirm_password': password,
                'submit': 'Register'
            }
            
            # Ajouter l'option startup rep si nécessaire
            if is_startup_rep:
                form_data['is_startup_rep'] = 'y'
            
            # Envoyer le formulaire
            headers = {
                'Referer': register_url,
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
            }
            
            async with session.post(register_url, data=form_data, headers=headers, timeout=15) as response:
                result = {
                    'success': response.status == 200 or response.status == 302,
                    'username': username,
                    'email': email,
                    'password': password,
                    'is_startup_rep': is_startup_rep,
                    'created_at': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                    'status_code': response.status
                }
                
                return result
    
    except asyncio.TimeoutError:
        return {'success': False, 'error': "Timeout lors de la requête"}
    except Exception as e:
        return {'success': False, 'error': str(e)}

# Fonction pour traiter un lot de comptes en parallèle
async def process_batch(batch_indices, startup_ratio, accounts):
    """Traite un lot de comptes en parallèle"""
    async with aiohttp.ClientSession() as session:
        tasks = []
        for i in batch_indices:
            if not config['is_running']:
                break
                
            is_startup = random.random() < startup_ratio
            tasks.append(create_account_async(session, is_startup_rep=is_startup))
        
        if not tasks:
            return []
            
        results = await asyncio.gather(*tasks, return_exceptions=True)
        
        # Traiter les résultats
        batch_results = []
        for idx, result in zip(batch_indices, results):
            if isinstance(result, Exception):
                config['progress']['failed'] += 1
                config['progress']['last_status'] = f"Échec de la création du compte {idx+1}: {str(result)}"
            elif result.get('success', False):
                config['progress']['success'] += 1
                config['progress']['last_username'] = result['username']
                config['progress']['last_status'] = f"Compte {idx+1} créé avec succès"
                accounts.append(result)
                batch_results.append(result)
            else:
                config['progress']['failed'] += 1
                config['progress']['last_status'] = f"Échec de la création du compte {idx+1}: {result.get('error', 'Erreur inconnue')}"
            
            config['progress']['current'] = idx + 1
        
        return batch_results

# Fonction principale pour créer des comptes de manière asynchrone
async def create_accounts_async(num_accounts, startup_ratio=0.3):
    """Crée plusieurs comptes en parallèle de manière asynchrone"""
    # Charger les comptes existants
    accounts = []
    if os.path.exists(config['accounts_file']):
        try:
            with open(config['accounts_file'], 'r') as f:
                accounts = json.load(f)
        except:
            accounts = []
    
    # Traiter les comptes par lots
    batch_size = config['batch_size']
    for start_idx in range(0, num_accounts, batch_size):
        if not config['is_running']:
            break
            
        end_idx = min(start_idx + batch_size, num_accounts)
        batch_indices = list(range(start_idx, end_idx))
        
        # Traiter un lot de comptes
        await process_batch(batch_indices, startup_ratio, accounts)
        
        # Enregistrer les données après chaque lot
        with open(config['accounts_file'], 'w') as f:
            json.dump(accounts, f, indent=2)
            
        # Petite pause pour éviter de surcharger le serveur
        await asyncio.sleep(1)
    
    return accounts

# Fonction pour lancer la création de comptes en arrière-plan
def create_accounts_background(num_accounts, startup_ratio=0.3):
    config['progress'] = {
        'total': num_accounts,
        'current': 0,
        'success': 0,
        'failed': 0,
        'last_username': '',
        'last_status': 'Démarrage...',
        'start_time': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        'end_time': None
    }
    
    # Créer une boucle asyncio dans un nouveau thread
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    
    try:
        accounts = loop.run_until_complete(create_accounts_async(num_accounts, startup_ratio))
        
        # Mise à jour finale
        config['progress']['end_time'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        config['progress']['last_status'] = "Terminé"
        
        # Enregistrement final
        with open(config['accounts_file'], 'w') as f:
            json.dump(accounts, f, indent=2)
            
    except Exception as e:
        config['progress']['last_status'] = f"Erreur: {str(e)}"
    finally:
        config['is_running'] = False
        loop.close()

# Routes Flask
@app.route('/')
def index():
    return render_template('index.html', config=config)

@app.route('/start', methods=['POST'])
def start():
    if config['is_running']:
        return jsonify({"status": "error", "message": "Une génération est déjà en cours"})
    
    num_accounts = int(request.form.get('num_accounts', 10))
    startup_ratio = float(request.form.get('startup_ratio', 0.3))
    batch_size = int(request.form.get('batch_size', config['batch_size']))
    
    # Mettre à jour la taille du lot
    config['batch_size'] = min(batch_size, 20)  # Limiter à 20 pour éviter de surcharger le serveur
    config['is_running'] = True
    
    # Démarrer le processus en arrière-plan
    thread = threading.Thread(target=create_accounts_background, args=(num_accounts, startup_ratio))
    thread.daemon = True
    thread.start()
    
    return jsonify({"status": "success", "message": "Génération démarrée"})

@app.route('/stop', methods=['POST'])
def stop():
    config['is_running'] = False
    return jsonify({"status": "success", "message": "Arrêt demandé"})

@app.route('/progress')
def progress():
    return jsonify(config['progress'])

@app.route('/accounts')
def view_accounts():
    page = int(request.args.get('page', 1))
    per_page = 20
    
    accounts = []
    if os.path.exists(config['accounts_file']):
        try:
            with open(config['accounts_file'], 'r') as f:
                accounts = json.load(f)
        except:
            accounts = []
            
    total_accounts = len(accounts)
    total_pages = (total_accounts + per_page - 1) // per_page
    
    start_idx = (page - 1) * per_page
    end_idx = start_idx + per_page
    
    current_accounts = accounts[start_idx:end_idx]
    
    return render_template(
        'accounts.html',
        accounts=current_accounts,
        page=page,
        total_pages=total_pages,
        total_accounts=total_accounts
    )

@app.route('/script.js')
def serve_js():
    return render_template('script.js'), 200, {'Content-Type': 'application/javascript'}

@app.route('/clear', methods=['POST'])
def clear_accounts():
    """Supprime tous les comptes enregistrés"""
    if os.path.exists(config['accounts_file']):
        try:
            os.remove(config['accounts_file'])
            return jsonify({"status": "success", "message": "Données des comptes supprimées"})
        except Exception as e:
            return jsonify({"status": "error", "message": f"Erreur lors de la suppression: {str(e)}"})
    return jsonify({"status": "success", "message": "Aucun fichier à supprimer"})

if __name__ == '__main__':
    app.run(debug=True)