import random
import requests
import time
from pathlib import Path


def generate_sample_data(base_url="http://localhost:8000", num_samples=100):
    """
    Generate sample data for the divisibility endpoint by making requests to the API.

    Args:
        base_url (str): Base URL of the API
        num_samples (int): Number of sample data points to generate
    """
    print(
        f"Generating {num_samples} sample data points for the Number Divisibility API..."
    )

    # Use both GET and POST endpoints to create diverse sample data
    for i in range(num_samples):
        method = "GET" if i % 2 == 0 else "POST"
        number = random.randint(1, 1000)  # Generate a random number between 1 and 1000

        try:
            if method == "GET":
                response = requests.get(f"{base_url}/divisibility/{number}")
            else:
                response = requests.post(
                    f"{base_url}/divisibility", json={"number": number}
                )

            if response.status_code == 200:
                result = response.json()
                print(
                    f"Added: Number {number} is{'' if result['is_divisible_by_2'] else ' not'} divisible by 2"
                )
            else:
                print(
                    f"Error: Failed to add number {number}. Status code: {response.status_code}"
                )

            # Add a small delay to avoid hammering the API
            time.sleep(0.1)

        except requests.RequestException as e:
            print(
                f"Error: Failed to connect to API at {base_url}. Make sure the API is running."
            )
            print(f"Exception: {e}")
            return False

    print("\nSample data generation completed.")
    print(f"Generated {num_samples} data points for the Number Divisibility API.")
    print(f"You can view the history at {base_url}/history")

    return True


def generate_offline_data(db_path="/app/storage/db/db.sqlite", num_samples=100):
    """
    Generate sample data directly to the database without making API requests.
    Use this when the API is not running.

    Args:
        db_path (str): Path to the SQLite database
        num_samples (int): Number of sample data points to generate
    """
    try:
        import sqlite3

        db_file = Path(db_path)

        # Check if database directory exists
        if not db_file.parent.exists():
            db_file.parent.mkdir(parents=True, exist_ok=True)

        # Connect to the database
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()

        # Create table if it doesn't exist
        cursor.execute("""
        CREATE TABLE IF NOT EXISTS number_checks (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            number INTEGER NOT NULL,
            is_divisible_by_2 BOOLEAN NOT NULL,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
        """)

        print(
            f"Generating {num_samples} sample data points directly to the database..."
        )

        # Generate sample data
        for i in range(num_samples):
            number = random.randint(1, 1000)
            is_divisible = number % 2 == 0

            cursor.execute(
                "INSERT INTO number_checks (number, is_divisible_by_2) VALUES (?, ?)",
                (number, is_divisible),
            )

            print(
                f"Added: Number {number} is{'' if is_divisible else ' not'} divisible by 2"
            )

        # Commit the changes
        conn.commit()
        conn.close()

        print("\nSample data generation completed.")
        print(f"Generated {num_samples} data points directly to the database.")

        return True

    except Exception as e:
        print("Error: Failed to generate offline data.")
        print(f"Exception: {e}")
        return False


if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(
        description="Generate sample data for the Number Divisibility API"
    )
    parser.add_argument(
        "--samples",
        type=int,
        default=100,
        help="Number of sample data points to generate",
    )
    parser.add_argument(
        "--url", type=str, default="http://localhost:8000", help="Base URL of the API"
    )
    parser.add_argument(
        "--offline",
        action="store_true",
        help="Generate data directly to the database without API requests",
    )
    parser.add_argument(
        "--db-path",
        type=str,
        default="/app/storage/db/db.sqlite",
        help="Path to the SQLite database file (for offline mode)",
    )

    args = parser.parse_args()

    if args.offline:
        generate_offline_data(db_path=args.db_path, num_samples=args.samples)
    else:
        generate_sample_data(base_url=args.url, num_samples=args.samples)