Skip to content

abhisheknaik2k20/Competitive_Coding_Arena

BranchesTags

Repository files navigation

🏆 Competitive Coding Arena

A comprehensive competitive programming platform built with Flutter, designed to provide an immersive coding experience with real-time collaboration, AI-powered features, and community engagement.

📋 Table of Contents

🎯 Overview

Competitive Coding Arena is a feature-rich platform that combines the best aspects of competitive programming platforms like LeetCode, HackerRank, and Codeforces. It offers a complete ecosystem for programmers to practice, compete, and collaborate in real-time.

🌟 Key Highlights

  • Real-time Collaborative Coding: Multiple users can code together with live synchronization
  • AI-Powered Problem Generation: Uses Google Gemini AI to create personalized coding problems and roadmaps
  • Interactive Learning Roadmaps: AI-generated personalized learning paths for skill development
  • Advanced Community Features: Location-based and skill-based user clustering with interactive maps
  • Live Competitive Contests: Real-time competitive programming contests with leaderboards
  • Multi-language Code Execution: Secure C++, Java, Python code compilation via AWS Lambda
  • Premium Subscription Management: Advanced features with Razorpay payment integration
  • Stack Overflow Clone: Built-in Q&A platform for coding help and discussion

✨ Features

🎮 Core Features

Problem Solving Platform

  • Extensive Problem Set: Curated collection of DSA problems with multiple difficulty levels
  • Advanced Code Editor: Syntax-highlighted code editor with multi-language support (C++, Java, Python)
  • Real-time Code Compilation: AWS Lambda-powered secure code execution with performance metrics
  • Intelligent Test Case Validation: Automatic test case running and comprehensive validation
  • Code Complexity Analysis: AI-powered time and space complexity analysis with improvement suggestions

Live Competitive Contests

  • Scheduled Contests: Weekly competitive programming contests with various formats
  • Real-time Leaderboards: Live ranking updates during contests with dynamic scoring
  • Team Participation: Support for both individual and team-based contests
  • Contest Registration: Streamlined registration process with team management and invitations
  • Contest Analytics: Detailed performance analysis and ranking history

Real-time Collaborative Environment

  • Live Code Sharing: Multiple users can edit code simultaneously with instant synchronization
  • Voice/Video Communication: Agora RTC integration for seamless team communication
  • Screen Sharing Capabilities: Share coding sessions with team members in real-time
  • Friend Invitation System: Push notification system for inviting friends to coding sessions
  • Collaborative Problem Solving: Team-based problem-solving with shared workspaces

🚀 Advanced Features

AI-Powered Learning System

  • Personalized Roadmaps: AI-generated learning paths based on user preferences, skill level, and goals
  • Intelligent Problem Recommendations: Smart problem suggestions based on solving patterns
  • Progress Tracking: Visual progress indicators with detailed analytics and performance insights
  • Adaptive Learning: Dynamic difficulty adjustment based on user performance
  • Learning Path Optimization: Continuous optimization of learning paths using machine learning

Advanced Community Platform

  • Stack Overflow Clone: Full-featured Q&A platform for coding help and knowledge sharing
  • Skill-based Clustering: Advanced algorithms to find users with similar coding skills and interests
  • Location-based Networking: Geographic clustering to connect with nearby programmers
  • Interactive Community Maps: Flutter Map integration for visualizing programmer communities
  • User Discovery System: Advanced search and filtering for finding coding partners

Premium Subscription Features

  • Advanced Performance Analytics: Detailed insights into coding patterns, time complexity analysis, and improvement areas
  • Premium AI Roadmaps: Enhanced AI-generated personalized learning paths with advanced recommendations
  • Priority Customer Support: Enhanced support with faster response times and dedicated assistance
  • Ad-free Experience: Clean, distraction-free interface without advertisements
  • Exclusive Content Access: Premium problems, tutorials, and coding challenges

🛠 Tech Stack

Frontend

  • Flutter: Cross-platform mobile and web development
  • Dart: Programming language for Flutter
  • Riverpod: State management solution
  • Material Design 3: Modern UI components

Backend & Cloud Services

  • Firebase: Backend-as-a-Service platform
    • Authentication: User management and OAuth
    • Firestore: NoSQL database for real-time data
    • Cloud Messaging: Push notifications
    • Analytics: User behavior tracking
  • AWS Lambda: Serverless code execution
  • Google Gemini AI: AI-powered content generation

Real-time Communication

  • Agora RTC: Voice and video calling
  • Firebase Realtime Database: Live code synchronization
  • WebRTC: Real-time communication protocols

Payment Integration

  • Razorpay: Payment gateway for premium subscriptions
  • Subscription Management: Automated billing and renewal

Maps & Location

  • Flutter Map: Interactive map visualization
  • Geolocator: Location services
  • Geocoding: Address to coordinates conversion

🏗 Architecture

App Architecture

├── Authentication Layer (Firebase Auth + Google OAuth)
├── State Management (Riverpod)
├── UI Layer (Material Design 3)
├── Business Logic Layer
├── Data Layer (Firebase Firestore)
└── External Services (AWS, Agora, Razorpay)

Data Flow

  1. User Authentication: Firebase Auth with Google OAuth integration
  2. Real-time Synchronization: Firestore listeners for live updates
  3. Code Execution: AWS Lambda functions for secure code compilation
  4. AI Integration: Google Gemini for content generation
  5. Notifications: Firebase Cloud Messaging for push notifications

🚀 Getting Started

Prerequisites

  • Flutter SDK (>=3.4.3)
  • Dart SDK
  • Firebase CLI
  • Android Studio / VS Code
  • Firebase project setup
  • AWS account (for Lambda functions)
  • Agora account (for RTC features)
  • Razorpay account (for payments)

Installation

  1. Clone the repository

    git clone https://github.com/your-username/competitive-coding-arena.git
cd competitive-coding-arena

  2. Install dependencies

    flutter pub get

  3. Firebase Setup

    firebase init
flutter packages pub run build_runner build

  4. Environment Configuration

    • Create lib/API_KEYS/api.dart with your API keys
    • Configure Firebase options in lib/firebase_options.dart

  5. Run the application

    flutter run -d web  # For web
flutter run         # For mobile

📁 Project Structure

lib/
├── main.dart                     # App entry point with theme management
├── firebase_options.dart         # Firebase configuration
├── options.dart                  # App-wide options and constants
│
├── API_KEYS/                     # API keys and configuration
│   └── api.dart                  # Centralized API key management
│
├── Auth_Profile_Logic/           # Authentication & Profile Management
│   ├── login_signup.dart         # Authentication logic
│   ├── login.dart               # Login UI components
│   └── Profile/                 # User profile management
│       └── ProfilePage.dart     # Comprehensive user profile display
│
├── AWS/                         # AWS Lambda Integration
│   └── compiler_call.dart      # Code compilation and AI clustering services
│
├── Core_Project/                # Main application features
│   ├── CodeScreen/              # Code editor and collaboration
│   │   ├── blackscreen.dart     # Main collaborative coding interface
│   │   ├── containers.dart      # Draggable UI containers
│   │   ├── invite_friends.dart  # Friend invitation system
│   │   ├── submission_screen.dart # Code submission analysis
│   │   ├── analyze_complexity.dart # AI-powered complexity analysis
│   │   └── providers.dart       # State management
│   │
│   ├── Contest/                 # Contest management system
│   │   ├── banner.dart          # Contest promotional banners
│   │   ├── contestclass.dart    # Contest data models
│   │   ├── featured.dart        # Featured contests display
│   │   ├── leaderboard.dart     # Real-time contest rankings
│   │   ├── onlineEditor.dart    # Contest-specific code editor
│   │   ├── register.dart        # Contest registration system
│   │   ├── roadmap.dart         # AI-powered learning roadmaps
│   │   └── providers.dart       # Contest state management
│   │
│   ├── Community/               # Community and networking features
│   │   ├── community.dart       # Main community interface
│   │   ├── Region_Based/        # Geographic clustering
│   │   │   ├── map_screen.dart  # Interactive programmer map
│   │   │   ├── map_data.dart    # Location data management
│   │   │   └── search_screen.dart # Institution-based search
│   │   └── Skill_Based/         # Algorithm-based clustering
│   │       ├── skill_cluster.dart # Skill clustering interface
│   │       └── data.dart        # User skill data models
│   │
│   ├── Problemset/              # Problem management system
│   │   ├── containers/          # Problem display components
│   │   │   └── homescreen.dart  # Main problem browsing interface
│   │   ├── examples/            # Sample problems and data
│   │   │   └── exampleprobs.dart # Problem class definitions
│   │   └── styles/              # UI styling components
│   │
│   └── Premium/                 # Premium subscription features
│       └── buy_membership.dart  # Razorpay payment processing
│
├── Stack_OverFlow/              # Q&A Platform (Stack Overflow Clone)
│   ├── problem_class.dart       # Q&A data models
│   ├── problem_screen.dart      # Question display interface
│   ├── stack_overflow_screen.dart # Main Q&A interface
│   ├── stack_screen_data.dart   # Q&A data management
│   ├── COMMAN_SCREENS/          # Shared Q&A components
│   │   ├── live_submissions.dart # Real-time submission tracking
│   │   ├── preview_submission.dart # Submission preview
│   │   ├── problem_description.dart # Problem description display
│   │   ├── problem_statement.dart # Problem statement formatting
│   │   ├── problem_title.dart   # Title management
│   │   └── submission_class.dart # Submission data models
│   ├── DIALOG/                  # Modal dialog components
│   │   ├── create_problem.dart  # Problem creation interface
│   │   ├── data.dart           # Dialog data management
│   │   └── submit_solution.dart # Solution submission dialog
│   └── WEB/                     # Web development resources
│       ├── browser_view.dart    # Embedded browser component
│       ├── htmlcss_code_snippets.dart # HTML/CSS examples
│       └── react_code_snippets.dart # React code examples
│
├── ImageScr/                    # Image and visual components
│   ├── homeScreen.dart          # Home screen image data
│   └── contestscreen.dart       # Contest visual elements
│
├── Messaging/                   # Push notifications
│   └── messages_logic.dart      # Firebase messaging integration
│
├── Transaction_GateWay/         # Payment processing
│   └── razorpay_screen.dart     # Razorpay integration
│
├── Welcome/                     # User onboarding
│   ├── welcome.dart             # Welcome screen
│   ├── styles/                  # Welcome screen styling
│   │   └── styles.dart
│   └── widgets/                 # Welcome screen components
│       ├── big_widgets.dart     # Major UI components
│       └── small_widgets.dart   # Minor UI elements
│
├── Error/                       # Error handling
│   └── error_widgets.dart       # Global error management
│
└── Snackbars&Pbars/            # UI feedback components
    └── snackbars.dart           # Notification and progress indicators

Asset Structure

assets/
├── images/                      # Static images
│   ├── bg.png                   # Background images
│   ├── logo.png                 # Application logo
│   ├── stflow.png              # Stack overflow styling
│   └── t.png                    # Additional graphics
└── sounds/                      # Audio assets
    └── mp.mp3                   # Background music

Web Configuration

web/
├── index.html                   # Main HTML entry point
├── firebase-messaging-sw.js     # Service worker for push notifications
├── manifest.json               # PWA configuration
├── favicon.png                 # Browser favicon
└── icons/                      # PWA icons
    ├── Icon-192.png            # Various sizes for different devices
    ├── Icon-512.png
    ├── Icon-maskable-192.png
    └── Icon-maskable-512.png

🔧 Key Components

1. Real-time Collaborative Code Editor (blackscreen.dart)

Advanced Collaborative Features:

  • Multi-user Simultaneous Editing: Multiple developers can edit the same code file in real-time with conflict resolution
  • Live Synchronization: Firebase Firestore integration for instant code synchronization across all connected users
  • Voice/Video Communication: Agora RTC integration enabling seamless voice and video calls during coding sessions
  • Draggable Container System: Customizable workspace with draggable containers for code, description, test cases, and console
  • Timer Management: Built-in contest countdown functionality with visual indicators
  • Friend Invitation System: Real-time push notifications for inviting friends to collaborative coding sessions

Implementation Highlights:

class BlackScreen extends StatefulWidget {
  final String? teamid;
  final Problem problem;
  final Size size;
  final bool isOnline;
  // Supports both online collaborative and offline individual coding modes
}

// Available draggable containers for workspace customization
const List<Map<String, dynamic>> _availableContainersData = [
  {'name': 'Description', 'icon': Icons.description, 'color': Colors.red},
  {'name': 'Code', 'icon': Icons.code, 'color': Colors.blue},
  {'name': 'Solutions', 'icon': Icons.lightbulb, 'color': Colors.yellow},
  {'name': 'TestCases', 'icon': Icons.check_box, 'color': Colors.green},
  {'name': 'Console', 'icon': Icons.check_box, 'color': Colors.indigo}
];

2. Contest Management System (Contest/)

Comprehensive Contest Infrastructure:

  • Registration Management: Streamlined team and individual contest registration with automated team formation
  • Live Leaderboards: Real-time ranking updates with dynamic scoring algorithms and performance metrics
  • Problem Distribution: Automated problem assignment with difficulty balancing and category distribution
  • Result Processing: Automated scoring, ranking calculation, and performance analysis
  • Contest Analytics: Detailed post-contest analysis with participant performance insights

Online Contest Editor Integration:

class OnlineCodeEditor extends StatefulWidget {
  final String? teamid;
  // Real-time collaborative editor specifically for contest environments
  // Includes automatic solution submission and leaderboard updates
}

3. AI-Powered Roadmap Generator (roadmap.dart)

Intelligent Learning Path Creation:

  • Gemini AI Integration: Advanced AI algorithms for generating personalized learning roadmaps
  • Progress Tracking: Visual progress indicators with milestone completion tracking
  • Interactive Visualization: Custom-painted hierarchical tree structure for roadmap navigation
  • Premium Feature Gating: Enhanced roadmap features available for premium subscribers
  • Dynamic Content Generation: AI-generated problems and learning materials for each roadmap step

Roadmap Visualization:

class RoadmapStep {
  final int number;
  final String title;
  final Color originalColor;
  Color currentColor;
  final List<int> children;
  double progress;
  // Represents individual learning milestones in the roadmap hierarchy
}

4. Community Networking Features (Community/)

Geographic-Based Networking:

  • Interactive Maps: Flutter Map integration with real-time programmer location visualization
  • Proximity Detection: Automatic discovery of nearby programmers within configurable radius
  • Institution Clustering: Educational institution-based user grouping and networking
  • Location Services: Geolocator integration for automatic location detection and updates

Skill-Based Algorithm Clustering:

  • Advanced Clustering Algorithms: Machine learning-based skill assessment and user grouping
  • Skill Distribution Analysis: Comprehensive analysis of programming strengths and weaknesses
  • Performance-Based Matching: Algorithm to match users with similar coding proficiency levels
  • Dynamic Cluster Updates: Real-time cluster rebalancing based on user progress and activity

5. Code Execution and Analysis System

AWS Lambda Integration:

  • Secure Code Execution: Sandboxed code compilation and execution for C++, Java, and Python
  • Performance Metrics: Detailed execution time, memory usage, and efficiency analysis
  • Test Case Validation: Comprehensive automated testing against predefined and custom test cases
  • Real-time Compilation: Sub-second code compilation and execution with instant feedback

AI-Powered Code Analysis:

// Gemini AI integration for code complexity analysis
Future<void> _analyzeComplexity() async {
  final model = GenerativeModel(
    model: 'gemini-1.5-pro', 
    apiKey: ApiKeys().geminiAPI
  );
  // Provides time/space complexity analysis and optimization suggestions
}

6. Premium Subscription Management

Razorpay Payment Integration:

  • Secure Payment Processing: Complete integration with Razorpay for subscription management
  • Automatic Billing: Recurring subscription handling with automated renewal notifications
  • Feature Access Control: Dynamic feature gating based on subscription status
  • Payment Analytics: Comprehensive subscription analytics and revenue tracking

Premium Feature Access:

  • Advanced AI Roadmaps: Enhanced personalization and career-specific learning paths
  • Priority Support: Dedicated customer support with faster response times
  • Advanced Analytics: Detailed performance insights and coding pattern analysis
  • Ad-free Experience: Clean interface without advertisements and distractions

🌍 Community Features

Geographic-Based Networking (lib/Core_Project/Community/Region_Based/)

Interactive Map Integration:

  • Flutter Map Implementation: Real-time map visualization using flutter_map package
  • Geolocator Integration: Automatic user location detection and nearby programmer discovery
  • Dynamic Programmer Discovery: Generates nearby programmers within configurable radius
  • Institution-Based Clustering: Groups users by educational institutions and organizations
// Real-time programmer discovery around user location
Future<void> _loadNearbyProgrammers() async {
  final random = math.Random();
  List<ProgrammerInfo> programmers = [];
  
  // Calculate radius and angle for nearby programmer placement
  double radius = _minProgrammerDistance + 
    random.nextDouble() * (_maxProgrammerDistance - _minProgrammerDistance);
  double angle = random.nextDouble() * 2 * math.pi;
  
  // Generate programmer info with location-based data
  programmers.add(ProgrammerInfo(
    name: '${names[random.nextInt(names.length)]}',
    specialty: 'Android/iOS/Web Development',
    location: calculatedLocation,
    profileImageUrl: profileUrls[random.nextInt(profileUrls.length)],
  ));
}

Skill-Based Clustering (lib/Core_Project/Community/Skill_Based/)

Advanced Algorithm Clustering: The platform uses sophisticated clustering algorithms to group users based on programming skills and expertise:

Cluster Categories:

  • Algorithm Experts: Users excelling in complex algorithmic problems
  • Data Structure Wizards: Specialists in advanced data structure implementations
  • Dynamic Programming Enthusiasts: Experts in DP problem-solving techniques
  • Graph Theory Masters: Users proficient in graph algorithms and network problems

Clustering Implementation:

final List<Map<String, dynamic>> skillClusteringData = [
  {
    'clusterName': 'Algorithm Experts',
    'users': [
      {
        'rating': 2450,
        'problemsSolved': 276,
        'topSkills': ['Greedy Algorithms', 'Divide & Conquer', 'Binary Search'],
        'skillDistribution': {
          'Greedy Algorithms': 92,
          'Divide & Conquer': 88,
          'Sorting': 95,
          'Searching': 90,
          'Dynamic Programming': 75
        }
      }
    ]
  }
];

Skill Analysis Features:

  • Performance Metrics: Detailed analysis of problem-solving patterns and efficiency
  • Skill Distribution Visualization: Radar charts showing strength across different programming domains
  • Recent Activity Tracking: Real-time monitoring of coding activity and problem-solving progress
  • Competitive Rating System: Advanced ELO-based rating system for skill assessment

Institution-Based Networking

Educational Institution Integration:

  • College/University Grouping: Automatic grouping of users from same educational institutions
  • Department-wise Clustering: Further subdivision based on academic departments
  • Alumni Networks: Connection with graduates from same institutions
  • Academic Competition Leaderboards: Institution-specific ranking systems

Featured Institution Data:

// Example: Thadomal Shahani Engineering College integration
List<Map<String, dynamic>> thadomalUsers = [
  {
    'name': 'Pranav Mahamunkar',
    'rating': '1200',
    'problemsSolved': 6,
    'joinDate': '4th Feb 2025',
    'topSkills': ['Greedy Algorithms', 'Sorting', 'Dynamic Programming']
  }
];

Social Features

User Interaction Systems:

  • Profile Detailed Views: Comprehensive user profiles with coding statistics and achievements
  • Achievement Badges: Gamified badge system for various programming milestones
  • Learning Path Sharing: Users can share and recommend learning paths to community
  • Code Collaboration: Real-time collaborative coding sessions with community members

Community Engagement:

  • Discussion Forums: Topic-wise discussion forums for algorithm discussions
  • Code Review Sessions: Peer-to-peer code review and feedback systems
  • Mentorship Programs: Connect beginners with experienced programmers
  • Study Groups: Formation of study groups based on skill levels and interests

🔥 Firebase Integration

Authentication

  • Google OAuth: Seamless Google sign-in
  • User Management: Profile creation and management
  • Session Handling: Persistent login states

Database (Firestore)

Collections:
├── users/                 # User profiles and preferences
├── contests/             # Contest information and participants
├── problems/             # Problem database
├── code/                 # Shared code sessions
├── stack_overflow_problems/ # Q&A content
└── submissions/          # Code submissions and results

Real-time Features

  • Live Code Synchronization: Instant code sharing
  • Contest Updates: Real-time leaderboard changes
  • Notifications: Push messaging for important events

☁️ AWS Integration

Lambda Functions for Code Execution

The platform leverages AWS Lambda for secure, scalable, and isolated code execution. Here's how the AWS section works:

Architecture Overview

Flutter App → HTTP Request → AWS Lambda → Code Execution → Response → Flutter App

Core Implementation (lib/AWS/compiler_call.dart)

Primary Compiler Function:

Future<Map<String, dynamic>> callCompiler(
    BuildContext context, String language, String code,
    {bool showProgress = true}) async {
  
  // Makes HTTP POST request to AWS Lambda endpoint
  final response = await http.post(
    Uri.parse(ApiKeys().compilerCall),
    headers: {'Content-Type': 'application/json; charset=UTF-8'},
    body: jsonEncode({
      "language": language, 
      "code": code
    })
  );
  
  // Processes response and returns execution results
  if (response.statusCode == 200) {
    return jsonDecode(response.body);
  }
  // Error handling for failed requests
}

AI Clustering Function:

Future<Map<String, dynamic>> invokeLambdaFunction() async {
  // Calls AWS Lambda for user skill clustering and roadmap generation
  final response = await http.post(
    Uri.parse(ApiKeys().clusterCall),
    body: jsonEncode({
      'user_data': {
        'user_id': FirebaseAuth.instance.currentUser!.uid,
        'topics': pickRandomTopic(allTopics),
        'journey': pickRandomTopic(journeys)
      },
      'reason': pickRandomString(reasons),
      'skillLevel': pickRandomString(skill)
    })
  );
}

Supported Languages

  • C++: Complete compilation with g++ compiler
  • Java: JDK-based compilation and execution
  • Python: Python 3.x interpreter with standard libraries

Security Features

  • Sandboxed Execution: Each code execution runs in an isolated Lambda environment
  • Resource Limits: Automatic CPU and memory constraints to prevent abuse
  • Timeout Handling: Automatic process termination for long-running code
  • Input Validation: Server-side validation of code input and language parameters
  • Error Containment: Secure error handling without exposing system information

Performance Metrics

  • Execution Time Tracking: Precise timing of code execution
  • Memory Usage Monitoring: Real-time memory consumption analysis
  • Response Time Optimization: Cached Lambda containers for faster execution
  • Load Balancing: Automatic scaling based on user demand

AWS Lambda Configuration

Runtime: Multiple (Node.js for orchestration, Python/Java/C++ for execution)
Memory: 512MB - 3GB (configurable based on language)
Timeout: 30 seconds maximum
Concurrency: Auto-scaling up to 1000 concurrent executions
Environment Variables: API keys, database connections, security tokens

Integration with Contest System

  • Real-time Judging: Instant code evaluation during contests
  • Batch Processing: Efficient handling of multiple submissions
  • Performance Ranking: Automatic ranking based on execution metrics
  • Test Case Validation: Comprehensive testing against hidden test cases

Cost Optimization

  • Efficient Resource Usage: Optimized Lambda functions to minimize execution time
  • Smart Caching: Reduced cold starts through container reuse
  • Request Batching: Grouped operations to reduce Lambda invocations
  • Monitoring & Alerts: CloudWatch integration for cost tracking and optimization

🤖 AI-Powered Features

Google Gemini Integration

The platform extensively uses Google Gemini AI for intelligent content generation and personalized learning experiences.

AI Roadmap Generation (lib/Core_Project/Contest/roadmap.dart)

Personalized Learning Path Creation:

// AI generates customized coding roadmaps based on user preferences
Map<String, dynamic> getdata = await invokeLambdaFunction();
Map<String, dynamic> body = jsonDecode(getdata['body']);
List<dynamic> programmingRoadmap = body['programming_roadmap'];

// Creates visual roadmap with progress tracking
List<Map<String, dynamic>> roadmapWithProgress = programmingRoadmap.map((step) {
  return {
    'title': step,
    'progress': 0,
  };
}).toList();

Interactive Roadmap Visualization:

  • Hierarchical Tree Structure: Custom-painted roadmap with interconnected learning nodes
  • Progress Tracking: Visual indicators showing completion status for each learning milestone
  • Dynamic Navigation: Click-through navigation to problem sets for each roadmap topic
  • Premium Gating: Advanced roadmaps available for premium subscribers

AI Problem Generation

Topic-Based Problem Creation:

static Future<List<Map<String, dynamic>>> getProblemsForTopic(String topic) async {
  final model = GenerativeModel(
    model: 'gemini-1.5-flash',
    apiKey: ApiKeys().geminiAPI,
  );
  
  final prompt = '''
  Generate 3-4 programming problems for the topic: $topic
  For each problem, provide:
  - A title, difficulty level (Easy, Medium, or Hard)
  - Description of the problem
  - Example input/output, constraints
  Format as JSON array...
  ''';
  
  final response = await model.generateContent([Content.text(prompt)]);
  // Parses AI response and returns structured problem data
}

Code Complexity Analysis (lib/Core_Project/CodeScreen/analyze_complexity.dart)

AI-Powered Code Analysis:

Future<void> _analyzeComplexity() async {
  final model = GenerativeModel(
    model: 'gemini-1.5-pro', 
    apiKey: ApiKeys().geminiAPI
  );
  
  final prompt = '''
  You are a code complexity analyzer. Analyze the following code:
  ${_codeController.text}
  
  Required JSON format:
  {
    "Time_Complexity": "O(n)",
    "Space_Complexity": "O(1)", 
    "Improvements": "optimization suggestions"
  }
  ''';
  
  final response = await model.generateContent([Content.text(prompt)]);
  // Displays complexity analysis with improvement suggestions
}

AI Features in Action

Smart Skill Clustering:

  • User Profiling: AI analyzes solving patterns to determine skill levels
  • Interest Matching: Groups users with similar programming interests and expertise
  • Learning Recommendations: Suggests optimal learning paths based on current skills
  • Progress Optimization: Continuously adapts recommendations based on user progress

Intelligent Problem Recommendations:

  • Difficulty Adaptation: AI adjusts problem difficulty based on user performance
  • Topic Balancing: Ensures comprehensive coverage across different programming topics
  • Weakness Identification: Identifies and targets specific areas needing improvement
  • Learning Style Adaptation: Customizes problem types based on user preferences

Automated Content Generation:

  • Dynamic Problem Creation: Generates fresh problems to prevent solution memorization
  • Contextual Hints: Provides intelligent hints without giving away solutions
  • Explanation Generation: Creates detailed explanations for complex algorithmic concepts
  • Code Review Automation: AI-powered code review with optimization suggestions

Premium AI Features

  • Advanced Roadmap Personalization: Enhanced AI algorithms for career-specific learning paths
  • Industry-Specific Preparation: Tailored preparation for specific companies (Google, Meta, Amazon)
  • Performance Prediction: AI predicts interview success probability based on practice performance
  • Adaptive Mock Interviews: AI-generated interview questions based on target company patterns

💎 Premium Features

Subscription Management

  • Razorpay Integration: Secure payment processing
  • Automatic Billing: Recurring subscription handling
  • Feature Gating: Premium content access control

Premium Benefits

  • AI Roadmaps: Personalized learning paths
  • Advanced Analytics: Detailed performance insights
  • Priority Support: Enhanced customer service
  • Ad-free Experience: Clean, distraction-free interface

🎨 UI/UX Features

Theming

  • Light/Dark Mode: Dynamic theme switching
  • Material Design 3: Modern, accessible design system
  • Responsive Design: Adaptive layouts for all screen sizes

Animations

  • Smooth Transitions: Custom animation controllers
  • Interactive Elements: Engaging user interactions
  • Loading States: Visual feedback for async operations

Accessibility

  • Screen Reader Support: Semantic labels and descriptions
  • Keyboard Navigation: Full keyboard accessibility
  • High Contrast: Visual accessibility features

🔧 Development Setup

Environment Variables

Create lib/API_KEYS/api.dart with your API credentials:

class ApiKeys {
  // AWS Lambda endpoints for code execution
  String get compilerCall => 'YOUR_AWS_LAMBDA_COMPILER_URL';
  String get clusterCall => 'YOUR_AWS_LAMBDA_CLUSTERING_URL';
  
  // Firebase configuration
  String get firebasendpoint => 'YOUR_FIREBASE_ENDPOINT';
  
  // AI integration
  String get geminiAPI => 'YOUR_GOOGLE_GEMINI_API_KEY';
  
  // Additional service integrations
  String get agoraAppId => 'YOUR_AGORA_APP_ID';
  String get razorpayKeyId => 'YOUR_RAZORPAY_KEY_ID';
  String get razorpayKeySecret => 'YOUR_RAZORPAY_KEY_SECRET';
}

AWS Lambda Setup

Compiler Lambda Function:

# Example Python Lambda function for code execution
import json
import subprocess
import tempfile
import os

def lambda_handler(event, context):
    language = event['language']
    code = event['code']
    
    # Create temporary file for code execution
    with tempfile.NamedTemporaryFile(mode='w', suffix=f'.{get_extension(language)}', delete=False) as f:
        f.write(code)
        filename = f.name
    
    try:
        # Execute code based on language
        if language == 'python':
            result = subprocess.run(['python3', filename], capture_output=True, text=True, timeout=30)
        elif language == 'java':
            # Compile and run Java code
            compile_result = subprocess.run(['javac', filename], capture_output=True, text=True)
            if compile_result.returncode == 0:
                result = subprocess.run(['java', filename[:-5]], capture_output=True, text=True, timeout=30)
        elif language == 'cpp':
            # Compile and run C++ code
            executable = filename[:-4]
            compile_result = subprocess.run(['g++', filename, '-o', executable], capture_output=True, text=True)
            if compile_result.returncode == 0:
                result = subprocess.run([executable], capture_output=True, text=True, timeout=30)
        
        return {
            'statusCode': 200,
            'body': json.dumps({
                'output': result.stdout,
                'error': result.stderr,
                'returnCode': result.returncode,
                'executionTime': calculate_execution_time(result)
            })
        }
    except subprocess.TimeoutExpired:
        return {
            'statusCode': 408,
            'body': json.dumps({'error': 'Code execution timeout'})
        }
    finally:
        os.unlink(filename)

AI Clustering Lambda Function:

# AI-powered user clustering and roadmap generation
import json
import openai
from sklearn.cluster import KMeans
import numpy as np

def lambda_handler(event, context):
    user_data = event['user_data']
    reason = event['reason']
    skill_level = event['skillLevel']
    
    # Generate personalized roadmap using AI
    roadmap = generate_ai_roadmap(user_data, reason, skill_level)
    
    return {
        'statusCode': 200,
        'body': json.dumps({
            'programming_roadmap': roadmap,
            'estimated_completion_time': calculate_completion_time(roadmap),
            'difficulty_distribution': analyze_difficulty(roadmap)
        })
    }

def generate_ai_roadmap(user_data, reason, skill_level):
    # AI logic for generating personalized learning paths
    # Integration with OpenAI/Gemini for intelligent roadmap creation
    pass

Firebase Configuration

Firestore Database Structure:

// Collection: users
users/{userId} {
  displayName: string,
  email: string,
  isPremium: boolean,
  roadmap: array,
  skillLevel: string,
  problemsSolved: number,
  rating: number,
  joinDate: timestamp,
  preferences: {
    theme: string,
    notifications: boolean,
    collaborationMode: string
  }
}

// Collection: contests
contests/{contestId} {
  title: string,
  description: string,
  startTime: timestamp,
  endTime: timestamp,
  participants: array,
  problems: array,
  leaderboard: array,
  registrationOpen: boolean
}

// Collection: code (for collaborative editing)
code/{sessionId} {
  uid: string,
  data: string,
  language: string,
  consoleOutput: string,
  lastModified: timestamp,
  collaborators: array
}

// Collection: problems
problems/{problemId} {
  title: string,
  description: string,
  difficulty: string,
  tags: array,
  testCases: array,
  solutions: {
    python: subcollection,
    java: subcollection,
    cpp: subcollection
  }
}

Firebase Security Rules:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Users can read/write their own data
    match /users/{userId} {
      allow read, write: if request.auth != null && request.auth.uid == userId;
    }
    
    // Contest data is readable by authenticated users
    match /contests/{contestId} {
      allow read: if request.auth != null;
      allow write: if request.auth != null && hasAdminRole();
    }
    
    // Code collaboration sessions
    match /code/{sessionId} {
      allow read, write: if request.auth != null && 
        (resource.data.uid == request.auth.uid || 
         request.auth.uid in resource.data.collaborators);
    }
    
    function hasAdminRole() {
      return get(/databases/$(database)/documents/users/$(request.auth.uid)).data.role == 'admin';
    }
  }
}

Build Configuration

Development Environment:

# Install dependencies
flutter pub get

# Run in debug mode with hot reload
flutter run --debug

# Run on web with specific port
flutter run -d web --web-port 3000

# Run with specific Firebase environment
flutter run --dart-define=ENVIRONMENT=development

Production Build:

# Build for web deployment
flutter build web --release --dart-define=ENVIRONMENT=production

# Build Android APK
flutter build apk --release --dart-define=ENVIRONMENT=production

# Build iOS app (requires macOS and Xcode)
flutter build ios --release --dart-define=ENVIRONMENT=production

# Build for Firebase Hosting
flutter build web --release && firebase deploy --only hosting

Docker Configuration:

# Dockerfile for web deployment
FROM nginx:alpine

# Copy built web files
COPY build/web /usr/share/nginx/html

# Copy nginx configuration
COPY nginx.conf /etc/nginx/nginx.conf

# Expose port 80
EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

Testing Configuration

Widget Testing:

// test/widget_test.dart
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:competitivecodingarena/main.dart';

void main() {
  testWidgets('App launches and displays welcome screen', (WidgetTester tester) async {
    await tester.pumpWidget(const MyApp());
    expect(find.text('Competitive Coding Arena'), findsOneWidget);
  });
  
  testWidgets('Code editor can be opened', (WidgetTester tester) async {
    // Test code editor functionality
  });
  
  testWidgets('Contest registration works', (WidgetTester tester) async {
    // Test contest registration flow
  });
}

Integration Testing:

# Run all tests
flutter test

# Run specific test file
flutter test test/widget_test.dart

# Run tests with coverage
flutter test --coverage

# Generate coverage report
genhtml coverage/lcov.info -o coverage/html

🤝 Contributing

We welcome contributions to the Competitive Coding Arena! Here's how you can help:

Getting Started

  1. Fork the repository on GitHub
  2. Clone your fork locally: 
    git clone https://github.com/your-username/competitive-coding-arena.git
cd competitive-coding-arena
  3. Create a feature branch from main: 
    git checkout -b feature/amazing-feature
  4. Set up development environment following the setup guide above
  5. Make your changes and test thoroughly
  6. Commit your changes with descriptive messages: 
    git commit -m 'Add amazing feature: detailed description'
  7. Push to your branch: 
    git push origin feature/amazing-feature
  8. Open a Pull Request with a comprehensive description

Development Guidelines

Code Standards:

  • Follow Flutter/Dart best practices and official style guidelines
  • Use meaningful variable and function names with proper documentation
  • Implement comprehensive error handling and edge case management
  • Write unit tests for new features and bug fixes
  • Ensure responsive design compatibility across all screen sizes
  • Test functionality across web, iOS, and Android platforms

Contribution Areas:

  • New Features: AI enhancements, community features, contest improvements
  • Bug Fixes: Performance optimizations, UI/UX improvements, functionality fixes
  • Documentation: Code documentation, API documentation, user guides
  • Testing: Unit tests, integration tests, performance testing
  • UI/UX: Design improvements, accessibility enhancements, user experience optimization

Pull Request Requirements:

  • Detailed description of changes and their impact
  • Screenshots or videos for UI/UX changes
  • Test coverage for new functionality
  • Updated documentation where applicable
  • Passes all existing tests and linting checks

Architecture Contributions

Adding New Features:

  • Follow the existing project structure and naming conventions
  • Implement proper state management using Riverpod
  • Integrate with Firebase for data persistence where needed
  • Add AWS Lambda functions for server-side processing if required
  • Include proper error handling and user feedback mechanisms

Performance Optimization:

  • Optimize widget builds and reduce unnecessary rebuilds
  • Implement efficient data fetching and caching strategies
  • Minimize AWS Lambda cold starts and execution time
  • Optimize image and asset loading for better performance

Community Guidelines

Code of Conduct:

  • Be respectful and inclusive in all interactions
  • Provide constructive feedback and helpful suggestions
  • Help newcomers learn and contribute effectively
  • Maintain a welcoming environment for all skill levels

Communication:

  • Use GitHub Issues for bug reports and feature requests
  • Join discussions in Pull Requests and provide valuable feedback
  • Ask questions if anything is unclear or needs clarification
  • Share your expertise and help others solve problems

📧 Support

For support, questions, and feedback:

Technical Support

Documentation & Resources

Community Support

Premium Support

Premium subscribers enjoy:

  • Priority Support: Faster response times and dedicated support channels
  • Direct Developer Access: Connect with our development team for complex issues
  • Custom Integration Help: Assistance with enterprise integrations and customizations
  • Training Sessions: One-on-one training sessions for advanced features

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

License Summary

  • ✅ Commercial Use: You can use this software for commercial purposes
  • ✅ Modification: You can modify the source code
  • ✅ Distribution: You can distribute the software
  • ✅ Private Use: You can use the software for private purposes
  • ❗ License and Copyright Notice: Include the original license and copyright notice
  • ❗ No Warranty: The software is provided "as is" without warranty

🙏 Acknowledgments

Technologies & Services

  • Flutter Team for the amazing cross-platform framework
  • Firebase for comprehensive backend-as-a-service solutions
  • AWS for scalable cloud computing and Lambda services
  • Google Gemini AI for advanced AI capabilities
  • Agora for real-time communication features
  • Razorpay for secure payment processing

Open Source Libraries

  • flutter_riverpod for state management
  • cloud_firestore for real-time database integration
  • agora_rtc_engine for voice/video communication
  • flutter_map for interactive map features
  • google_generative_ai for AI integration
  • fl_chart for data visualization
  • And many other amazing open-source contributors

Special Thanks

  • Beta Testers who provided valuable feedback during development
  • Early Adopters who helped shape the platform's direction
  • Contributors who submitted bug reports, feature requests, and code improvements
  • Educational Institutions that partnered with us for testing and feedback

Built with ❤️ by the Competitive Coding Arena Team

Empowering developers worldwide to excel in competitive programming and collaborative coding

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Languages