import qubots.rastion as rastion

# Authenticate with your API token
rastion.authenticate("your_api_token_here")

from qubots import get_standardized_problems

# Get list of available benchmark problems
problems = get_standardized_problems()

for problem in problems:
    print(f"Problem ID: {problem.id}")
    print(f"Name: {problem.name}")
    print(f"Category: {problem.category}")
    print(f"Difficulty: {problem.difficulty}")
    print(f"Current best: {problem.current_best_value}")
    print("---")

from qubots import submit_to_leaderboard, AutoOptimizer, AutoProblem

# Load your optimizer and problem
optimizer = AutoOptimizer.from_repo("my_username/my_optimizer")
problem = AutoProblem.from_repo("examples/tsp_benchmark")

# Run optimization
result = optimizer.optimize(problem)

# Submit to leaderboard
submission = submit_to_leaderboard(
    result=result,
    problem_id=1,  # TSP benchmark problem
    solver_name="MyGeneticAlgorithm",
    solver_repository="my_username/my_optimizer",
    solver_config={
        "version": "1.2.0",
        "population_size": 100,
        "generations": 1000
    }
)

print(f"Submission ID: {submission.id}")
print(f"Status: {submission.status}")

from qubots import LeaderboardClient

client = LeaderboardClient()

# Get problem leaderboard
leaderboard = client.get_problem_leaderboard(problem_id=1)

# Get submission details
submission = client.get_submission(submission_id="sub_123")

# Get user's submissions
my_submissions = client.get_user_submissions()

class LeaderboardSubmission:
    id: str                    # Unique submission identifier
    problem_id: int           # Problem identifier
    solver_name: str          # Name of the optimization algorithm
    solver_repository: str    # Repository containing the solver
    solver_config: Dict       # Configuration used for optimization
    result_value: float       # Objective value achieved
    execution_time: float     # Time taken for optimization
    submission_time: datetime # When the submission was made
    status: str              # Evaluation status
    rank: int                # Current rank on leaderboard

class StandardizedProblem:
    id: int                   # Problem identifier
    name: str                # Problem name
    description: str         # Problem description
    category: str            # Problem category (TSP, MaxCut, etc.)
    difficulty: str          # Difficulty level
    objective_type: str      # Minimize or maximize
    evaluation_metric: str   # Primary evaluation metric
    time_limit: int          # Maximum execution time
    current_best_value: float # Current best known value
    total_submissions: int   # Number of submissions

# Example ranking calculation
def calculate_rank(submissions):
    for submission in submissions:
        # Primary: objective value
        primary_score = submission.result_value
        
        # Secondary: execution time (tie-breaker)
        time_penalty = submission.execution_time / time_limit
        
        # Final score
        submission.score = primary_score + (time_penalty * 0.1)
    
    # Sort and assign ranks
    submissions.sort(key=lambda s: s.score)
    for i, submission in enumerate(submissions):
        submission.rank = i + 1

from qubots import LeaderboardClient

client = LeaderboardClient()

# Submit multiple configurations
configs = [
    {"population_size": 50, "generations": 500},
    {"population_size": 100, "generations": 1000},
    {"population_size": 200, "generations": 2000}
]

submissions = []
for config in configs:
    # Run optimization with config
    result = optimizer.optimize(problem, config=config)
    
    # Submit to leaderboard
    submission = submit_to_leaderboard(
        result=result,
        problem_id=1,
        solver_name=f"MyAlgorithm_v{config['population_size']}",
        solver_repository="my_username/my_optimizer",
        solver_config=config
    )
    submissions.append(submission)

# Get detailed performance analysis
analysis = client.get_performance_analysis(
    problem_id=1,
    user_submissions_only=True
)

print(f"Best rank achieved: {analysis.best_rank}")
print(f"Average rank: {analysis.average_rank}")
print(f"Improvement over time: {analysis.improvement_trend}")

# Compare with top performers
top_performers = client.get_top_performers(problem_id=1, limit=10)
for performer in top_performers:
    print(f"{performer.solver_name}: {performer.result_value}")

# Follow interesting submissions
client.follow_submission(submission_id="sub_123")

# Get notifications for new submissions
notifications = client.get_leaderboard_notifications()

# Share insights and discussions
client.add_submission_comment(
    submission_id="sub_123",
    comment="Interesting approach! How did you handle local optima?"
)

# Check submission status
submission = client.get_submission(submission_id)
if submission.status == "failed":
    print(f"Error: {submission.error_message}")
    print(f"Logs: {submission.evaluation_logs}")