# Check for linting issues
swiftlint lint

# Auto-fix linting issues
swiftlint --fix

# Format code
swiftformat .

# Check formatting without applying
swiftformat --lint .

// Good: Logic in ViewModel
class ConnectionViewModel: ObservableObject {
    func validateConnection() -> Bool {
        return !host.isEmpty && port > 0
    }
}

// Bad: Logic in View
struct ConnectionView: View {
    var body: some View {
        Button("Connect") {
            // Don't put validation logic here
        }
        .disabled(host.isEmpty || port <= 0)
    }
}

// Good: Value type for data
struct DatabaseConnection: Codable {
    let id: UUID
    var name: String
    var host: String
}

// When to use class: shared state, identity matters
@MainActor
class DatabaseManager: ObservableObject {
    static let shared = DatabaseManager()
}

// Good
let connection = DatabaseConnection(...)
let results = try await driver.execute(query: sql)

// Only var when needed
var currentPage = 1
currentPage += 1

var isConnected: Bool
var hasValidCredentials: Bool
var canExecuteQuery: Bool

func makeConnection() -> DatabaseConnection
func makeDriver(for type: DatabaseType) -> DatabaseDriver

// Good: Line breaks for readability
let result = try await driver.executeParameterized(
    query: "SELECT * FROM users WHERE email = ?",
    parameters: [email]
)

// Avoid: Long single line
let result = try await driver.executeParameterized(query: "SELECT * FROM users WHERE email = ?", parameters: [email])

// Good
if condition {
    doSomething()
} else {
    doSomethingElse()
}

// Bad
if condition
{
    doSomething()
}

// Space around operators
let sum = a + b
let isValid = count > 0 && name.isEmpty == false

// No space for ranges
for i in 0..<10 { }

// Space after colon in type declarations
var name: String
func connect(host: String, port: Int)

// Good: Explicit access
private var connectionPool: [Connection] = []
internal func processResult(_ result: QueryResult)
public func connect() async throws

// Avoid: Implicit internal
var connectionPool: [Connection] = []  // Implicit internal

class DatabaseManager {
    // Public API
    public func connect() async throws { ... }

    // Internal helpers
    private func validateConnection() -> Bool { ... }
    private var activeDriver: DatabaseDriver?
}

// Good
public extension NSEvent {
    var semanticKeyCode: KeyCode? { ... }
}

// Avoid
extension NSEvent {
    public var semanticKeyCode: KeyCode? { ... }
}

// Good
if let connection = connection {
    use(connection)
}

guard let result = result else { return }

// Bad
let connection = connection!  // Crash if nil

// Good
if let value = param as? SQLFunctionLiteral {
    return value.property
}

// Bad
let value = param as! SQLFunctionLiteral  // Crash if wrong type

// Good
func processResult(_ result: QueryResult?) -> [Row] {
    guard let result = result else { return [] }
    guard result.rowCount > 0 else { return [] }

    return result.rows.map { transform($0) }
}

// Avoid deep nesting
func processResult(_ result: QueryResult?) -> [Row] {
    if let result = result {
        if result.rowCount > 0 {
            return result.rows.map { transform($0) }
        }
    }
    return []
}

// Good
if items.isEmpty { }
if items.contains(target) { }
if let first = items.first(where: { $0.isValid }) { }

// Avoid
if items.count == 0 { }
if items.filter({ $0 == target }).count > 0 { }
if let first = items.filter({ $0.isValid }).first { }

// Good
items.map { item in item.value }
items.map(\.value)

// Avoid (if index not used)
items.enumerated().map { _, item in item.value }

// Good
items.filter { $0.isActive }
    .map { $0.name }

// Avoid
items.filter({ $0.isActive })
    .map({ $0.name })

// Good
items.map { $0.name }
items.filter { $0.isActive }

// Also good when clearer
items.map { item in
    item.name
}

// Good
button.onTap { _ in
    handleTap()
}

// Avoid
button.onTap { event in  // event not used
    handleTap()
}

// Good: Explain "why", not "what"
// We use a 1.5 second delay to ensure the SSH tunnel is established
// before attempting the database connection
try await Task.sleep(nanoseconds: 1_500_000_000)

// Avoid: Obvious comments
// Get the user's name
let name = user.name

/// Executes a SQL query and returns the results.
///
/// - Parameter query: The SQL query to execute
/// - Returns: A `QueryResult` containing rows and columns
/// - Throws: `DatabaseError` if the query fails
func execute(query: String) async throws -> QueryResult

// MARK: - Properties

private var connection: DatabaseConnection
private var driver: DatabaseDriver?

// MARK: - Lifecycle

init(connection: DatabaseConnection) {
    self.connection = connection
}

// MARK: - Public Methods

func connect() async throws { ... }

// MARK: - Private Helpers

private func validateConnection() -> Bool { ... }

struct ContentView: View {
    // MARK: - Properties

    @StateObject private var viewModel = ContentViewModel()
    @State private var isLoading = false

    // MARK: - Body

    var body: some View {
        VStack {
            headerView
            contentView
            footerView
        }
    }

    // MARK: - Subviews

    private var headerView: some View {
        Text("Header")
    }

    private var contentView: some View {
        // ...
    }
}

struct MyView: View {
    // Environment
    @Environment(\.dismiss) private var dismiss
    @EnvironmentObject private var appState: AppState

    // State Objects
    @StateObject private var viewModel = MyViewModel()

    // State
    @State private var isEditing = false
    @Binding var selection: Item?

    // Regular properties
    let title: String
}