LeetCode iOS app - v0 by Vercel

I'd be happy to guide you through creating an iPhone app using UIKit for LeetCode statistics. As you're new to iOS development, we'll break this down into manageable steps. Let's get started!

Step 1: Set up the project

Open Xcode and create a new project.
Choose "App" under the iOS tab.
Name your project (e.g., "LeetCodeStats").
Choose "Storyboard" for the interface and "UIKit App Delegate" for lifecycle.
Select a location to save your project.

Step 2: Design the main interface

Let's start with a tab bar interface to organize different sections of the app.

Open Main.storyboard.
Drag a Tab Bar Controller from the Object Library to the storyboard.
Delete the existing View Controller and set the Tab Bar Controller as the initial view controller.
Add four view controllers, one for each tab:
- Statistics
- Problem of the Day
- Problem List
- Profile
Control-drag from the Tab Bar Controller to each view controller and select "view controllers" to connect them.
Select each tab bar item and set its title and icon in the Attributes Inspector:
- Statistics: "Stats" with a chart icon
- Problem of the Day: "Daily" with a calendar icon
- Problem List: "Problems" with a list icon
- Profile: "Profile" with a person icon

Step 3: Create view controller classes

Create a new Swift file for each view controller:
- StatisticsViewController.swift
- DailyProblemViewController.swift
- ProblemListViewController.swift
- ProfileViewController.swift
In each file, create a subclass of UIViewController:

import UIKit

class StatisticsViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
    }
}

In the storyboard, set the custom class for each view controller to its corresponding Swift class.

Step 4: Implement networking

Create a NetworkManager class to handle API requests:

Create a new Swift file named NetworkManager.swift.
Add the following code:

import Foundation

class NetworkManager {
    static let shared = NetworkManager()
    private init() {}
    
    func fetchData(from url: URL, completion: @escaping (Result<Data, Error>) -> Void) {
        URLSession.shared.dataTask(with: url) { data, response, error in
            if let error = error {
                completion(.failure(error))
                return
            }
            
            guard let data = data else {
                completion(.failure(NSError(domain: "No Data", code: 0, userInfo: nil)))
                return
            }
            
            completion(.success(data))
        }.resume()
    }
}

Step 5: Create data models

Create Swift files for your data models:

UserStats.swift:

struct UserStats: Codable {
    let easySolved: Int
    let mediumSolved: Int
    let hardSolved: Int
    let totalSolved: Int
    let streak: Int
}

Problem.swift:

struct Problem: Codable {
    let id: Int
    let title: String
    let difficulty: String
    let acceptanceRate: Double
}

Step 6: Implement the Statistics View Controller

Update StatisticsViewController.swift:

import UIKit
import Charts

class StatisticsViewController: UIViewController {
    @IBOutlet weak var totalSolvedLabel: UILabel!
    @IBOutlet weak var streakLabel: UILabel!
    @IBOutlet weak var pieChartView: PieChartView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        fetchUserStats()
    }
    
    func fetchUserStats() {
        guard let url = URL(string: "https://leetcode.com/api/problems/all/") else { return }
        
        NetworkManager.shared.fetchData(from: url) { result in
            switch result {
            case .success(let data):
                do {
                    let stats = try JSONDecoder().decode(UserStats.self, from: data)
                    DispatchQueue.main.async {
                        self.updateUI(with: stats)
                    }
                } catch {
                    print("Error decoding JSON: \(error)")
                }
            case .failure(let error):
                print("Error fetching data: \(error)")
            }
        }
    }
    
    func updateUI(with stats: UserStats) {
        totalSolvedLabel.text = "Total Solved: \(stats.totalSolved)"
        streakLabel.text = "Streak: \(stats.streak)"
        
        let entries = [
            PieChartDataEntry(value: Double(stats.easySolved), label: "Easy"),
            PieChartDataEntry(value: Double(stats.mediumSolved), label: "Medium"),
            PieChartDataEntry(value: Double(stats.hardSolved), label: "Hard")
        ]
        
        let dataSet = PieChartDataSet(entries: entries, label: "")
        dataSet.colors = [.green, .orange, .red]
        
        let data = PieChartData(dataSet: dataSet)
        pieChartView.data = data
    }
}

Note: You'll need to add the Charts framework to your project for the pie chart functionality.

Step 7: Implement the Daily Problem View Controller

Update DailyProblemViewController.swift:

import UIKit

class DailyProblemViewController: UIViewController {
    @IBOutlet weak var titleLabel: UILabel!
    @IBOutlet weak var difficultyLabel: UILabel!
    @IBOutlet weak var descriptionTextView: UITextView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        fetchDailyProblem()
    }
    
    func fetchDailyProblem() {
        guard let url = URL(string: "https://leetcode.com/problems/random-one-question/all") else { return }
        
        NetworkManager.shared.fetchData(from: url) { result in
            switch result {
            case .success(let data):
                do {
                    let problem = try JSONDecoder().decode(Problem.self, from: data)
                    DispatchQueue.main.async {
                        self.updateUI(with: problem)
                    }
                } catch {
                    print("Error decoding JSON: \(error)")
                }
            case .failure(let error):
                print("Error fetching data: \(error)")
            }
        }
    }
    
    func updateUI(with problem: Problem) {
        titleLabel.text = problem.title
        difficultyLabel.text = problem.difficulty
        // You would need to fetch the problem description separately
        descriptionTextView.text = "Problem description goes here..."
    }
}

Step 8: Implement the Problem List View Controller

Update ProblemListViewController.swift:

import UIKit

class ProblemListViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
    @IBOutlet weak var tableView: UITableView!
    var problems: [Problem] = []
    
    override func viewDidLoad() {
        super.viewDidLoad()
        tableView.dataSource = self
        tableView.delegate = self
        fetchProblems()
    }
    
    func fetchProblems() {
        guard let url = URL(string: "https://leetcode.com/api/problems/all/") else { return }
        
        NetworkManager.shared.fetchData(from: url) { result in
            switch result {
            case .success(let data):
                do {
                    let problemList = try JSONDecoder().decode([Problem].self, from: data)
                    DispatchQueue.main.async {
                        self.problems = problemList
                        self.tableView.reloadData()
                    }
                } catch {
                    print("Error decoding JSON: \(error)")
                }
            case .failure(let error):
                print("Error fetching data: \(error)")
            }
        }
    }
    
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return problems.count
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "ProblemCell", for: indexPath)
        let problem = problems[indexPath.row]
        cell.textLabel?.text = problem.title
        cell.detailTextLabel?.text = problem.difficulty
        return cell
    }
}

Step 9: Implement the Profile View Controller

Update ProfileViewController.swift:

import UIKit

class ProfileViewController: UIViewController {
    @IBOutlet weak var usernameLabel: UILabel!
    @IBOutlet weak var totalSolvedLabel: UILabel!
    @IBOutlet weak var calendarView: UICollectionView! // You'll need to implement a custom calendar view
    
    override func viewDidLoad() {
        super.viewDidLoad()
        fetchUserProfile()
    }
    
    func fetchUserProfile() {
        // Fetch user profile data from LeetCode API
        // Update UI with fetched data
    }
}

Step 10: Implement data persistence

Use Core Data to store user information and solved problems locally. This will require setting up a Core Data model and implementing methods to save and retrieve data.

Step 11: Add authentication

Implement a login screen and use LeetCode's authentication API to allow users to log in to their accounts.

Step 12: Implement problem solving functionality

Add a web view or integrate a code editor to allow users to solve problems within the app.

Step 13: Testing and refinement

Test your app thoroughly on different devices and iOS versions. Refine the UI and fix any bugs you encounter.

Step 14: Submission to App Store

Prepare your app for submission to the App Store, including creating screenshots, writing a description, and setting up your developer account.

This is a basic structure for your LeetCode stats app. You'll need to flesh out each part with more detailed implementations, error handling, and UI refinements. Also, please note that you'll need to check LeetCode's terms of service and API documentation to ensure you're using their data in compliance with their policies.

As you're new to iOS development, I recommend going through each step slowly, researching any unfamiliar concepts, and practicing with smaller projects before tackling this entire app. Good luck with your development journey!