# Kiểm tra các vấn đề linting
swiftlint lint

# Tự động sửa các vấn đề linting
swiftlint --fix

# Format code
swiftformat .

# Kiểm tra formatting mà không áp dụng
swiftformat --lint .

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

// Không tốt: Logic trong View
struct ConnectionView: View {
    var body: some View {
        Button("Connect") {
            // Không đặt logic validation ở đây
        }
        .disabled(host.isEmpty || port <= 0)
    }
}

// Tốt: Value type cho dữ liệu
struct DatabaseConnection: Codable {
    let id: UUID
    var name: String
    var host: String
}

// Khi nào dùng class: shared state, identity quan trọng
@MainActor
class DatabaseManager: ObservableObject {
    static let shared = DatabaseManager()
}

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

// Chỉ dùng var khi cần
var currentPage = 1
currentPage += 1

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

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

// Tốt: Ngắt dòng để dễ đọc
let result = try await driver.executeParameterized(
    query: "SELECT * FROM users WHERE email = ?",
    parameters: [email]
)

// Tránh: Dòng dài đơn
let result = try await driver.executeParameterized(query: "SELECT * FROM users WHERE email = ?", parameters: [email])

// Tốt
if condition {
    doSomething()
} else {
    doSomethingElse()
}

// Không tốt
if condition
{
    doSomething()
}

// Khoảng trắng xung quanh operators
let sum = a + b
let isValid = count > 0 && name.isEmpty == false

// Không có khoảng trắng cho ranges
for i in 0..<10 { }

// Khoảng trắng sau colon trong khai báo type
var name: String
func connect(host: String, port: Int)

// Tốt: Access rõ ràng
private var connectionPool: [Connection] = []
internal func processResult(_ result: QueryResult)
public func connect() async throws

// Tránh: 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?
}

// Tốt
public extension NSEvent {
    var semanticKeyCode: KeyCode? { ... }
}

// Tránh
extension NSEvent {
    public var semanticKeyCode: KeyCode? { ... }
}

// Tốt
if let connection = connection {
    use(connection)
}

guard let result = result else { return }

// Không tốt
let connection = connection!  // Crash nếu nil

// Tốt
if let value = param as? SQLFunctionLiteral {
    return value.property
}

// Không tốt
let value = param as! SQLFunctionLiteral  // Crash nếu sai type

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

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

// Tránh nesting sâu
func processResult(_ result: QueryResult?) -> [Row] {
    if let result = result {
        if result.rowCount > 0 {
            return result.rows.map { transform($0) }
        }
    }
    return []
}

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

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

// Tốt
items.map { item in item.value }
items.map(\.value)

// Tránh (nếu index không được dùng)
items.enumerated().map { _, item in item.value }

// Tốt
items.filter { $0.isActive }
    .map { $0.name }

// Tránh
items.filter({ $0.isActive })
    .map({ $0.name })

// Tốt
items.map { $0.name }
items.filter { $0.isActive }

// Cũng tốt khi rõ ràng hơn
items.map { item in
    item.name
}

// Tốt
button.onTap { _ in
    handleTap()
}

// Tránh
button.onTap { event in  // event không được dùng
    handleTap()
}

// Tốt: Giải thích "tại sao", không phải "cái gì"
// Chúng ta dùng delay 1.5 giây để đảm bảo SSH tunnel được thiết lập
// trước khi thử kết nối database
try await Task.sleep(nanoseconds: 1_500_000_000)

// Tránh: Comments hiển nhiên
// Lấy tên user
let name = user.name

/// Thực thi SQL query và trả về kết quả.
///
/// - Parameter query: SQL query cần thực thi
/// - Returns: `QueryResult` chứa rows và columns
/// - Throws: `DatabaseError` nếu query thất bại
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
}