from flask import Flask, render_template, request, jsonify, redirect, url_for
import random
import string
import json
import threading
import os
import time
from datetime import datetime

# --- Selenium Imports ---
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.service import Service as ChromeService
from webdriver_manager.chrome import ChromeDriverManager

app = Flask(__name__)

# Configuration globale
config = {
    'base_url': "https://ivoire-startup-tracker-edithbrou.replit.app",
    'accounts_file': "accounts_data.json",
    'is_running': False,
    '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 (min 3 caractères)
def generate_random_username(min_length=3, max_length=10):  # Adjusted min_length
    """Génère un nom d'utilisateur aléatoire d'au moins 3 caractères"""
    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 au format plus standard"""
    username = ''.join(random.choice(string.ascii_lowercase) for _ in range(7))
    domains = ["gmail.com", "yahoo.com", "outlook.com", "example.com"]
    return f"{username}+{int(time.time())}@{random.choice(domains)}" # Added timestamp

# Fonction pour générer un mot de passe aléatoire
def generate_random_password(min_length=6, max_length=12):  # Adjusted min_length
    """Génère un mot de passe aléatoire"""
    chars = string.ascii_letters + string.digits + "!@#$%^&*"
    length = random.randint(min_length, max_length)
    return ''.join(random.choice(chars) for _ in range(length))

# Fonction pour créer un compte
def create_account(is_startup_rep=False):
    """Crée un compte sur le site web en utilisant Selenium"""
    register_url = f"{config['base_url']}/register"

    # Use webdriver_manager to handle ChromeDriver
    service = ChromeService(executable_path=ChromeDriverManager().install())
    options = webdriver.ChromeOptions()
    options.add_argument('--headless') # Run in headless mode (no GUI)
    options.add_argument('--no-sandbox') # Needed for Replit/containers
    options.add_argument('--disable-dev-shm-usage') # Also for Replit

    driver = webdriver.Chrome(service=service, options=options)

    try:
        driver.get(register_url)

        # Wait for the form to be present (important for dynamic pages)
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "username"))
        )

        # Generate random account data
        username = generate_random_username()
        email = generate_random_email()
        password = generate_random_password()

        # Fill out the form fields
        driver.find_element(By.ID, "username").send_keys(username)
        driver.find_element(By.ID, "email").send_keys(email)
        driver.find_element(By.ID, "password").send_keys(password)
        driver.find_element(By.ID, "confirm_password").send_keys(password)

        if is_startup_rep:
            driver.find_element(By.ID, "is_startup_rep").click()

        # Submit the form
        driver.find_element(By.ID, "submit").click()

        # Wait for a result (either success or failure) - Adjust the wait time as needed
        # We'll check for redirection as an indicator of success.  A more robust check
        # might involve looking for specific success/error messages on the resulting page.
        WebDriverWait(driver, 10).until(
            EC.url_changes(register_url)
        )
        
        # Check if redirection occurred to a URL other than the registration URL
        current_url = driver.current_url
        if current_url != register_url:
            success = True
        else:
             success = False # Explicitly set to False


        result = {
            'success': success,
            'username': username,
            'email': email,
            'password': password,
            'is_startup_rep': is_startup_rep,
            'created_at': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        }

        return result

    except Exception as e:
        print(f"Selenium Error: {e}")  # Log the Selenium error
        return {'success': False, 'error': str(e)}
    finally:
        driver.quit()  # Always close the browser

# Fonction pour créer plusieurs 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
    }
    
    # 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 = []
    
    for i in range(num_accounts):
        if not config['is_running']:
            break
            
        is_startup = random.random() < startup_ratio
        
        config['progress']['current'] = i + 1
        config['progress']['last_status'] = f"Création du compte {i+1}/{num_accounts}..."
        
        result = create_account(is_startup_rep=is_startup)
        
        if result.get('success', False):
            config['progress']['success'] += 1
            config['progress']['last_username'] = result['username']
            config['progress']['last_status'] = f"Compte {i+1} créé avec succès"
            accounts.append(result)
        else:
            config['progress']['failed'] += 1
            config['progress']['last_status'] = f"Échec de la création du compte {i+1}: {result.get('error', 'Erreur inconnue')}"
        
        # Enregistrer les données régulièrement
        with open(config['accounts_file'], 'w') as f:
            json.dump(accounts, f, indent=2)
            
        # Petite pause pour éviter de surcharger le serveur
        time.sleep(1)
    
    config['is_running'] = False
    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)


# 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))

    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'}

if __name__ == '__main__':
    app.run(debug=True) # Keep debug=True for development