Arithmetic Operators

// Basic arithmetic operators
let addition = 5 + 3        // 8
let subtraction = 10 - 4    // 6
let multiplication = 3 * 6  // 18
let division = 20 / 5       // 4

// Compound assignment operators
var number = 10
number += 5  // Same as: number = number + 5
number *= 2  // Same as: number = number * 2

// Type safety examples
let integerValue: Int = 42
let doubleValue: Double = 42.0

// This won't compile:
// let result = integerValue + doubleValue

// Correct way with explicit conversion:
let result = Double(integerValue) + doubleValue

// Integer types
let signedInteger: Int = -42        // Platform-dependent size (32 or 64 bit)
let unsignedInteger: UInt = 42      // Positive numbers only
let specific32Bit: Int32 = 42       // Exactly 32 bits
let specific64Bit: Int64 = 42       // Exactly 64 bits

// Floating-point types
let floatValue: Float = 42.0        // 32-bit floating point
let doubleValue: Double = 42.0      // 64-bit floating point (default)
let decimalValue = Decimal(42.0)    // High-precision decimal

struct NumericExample: View {
    // State variables for different numeric types
    @State private var intValue: Int = 0
    @State private var doubleValue: Double = 0.0

    var body: some View {
        VStack {
            // Integer operations
            Text("Integer: \(intValue)")
                .onTapGesture {
                    intValue += 1  // Clean integer increment
                }

            // Double operations with formatting
            Text("Double: \(doubleValue, specifier: "%.2f")")
                .onTapGesture {
                    doubleValue += 0.1  // Floating point increment
                }
        }
    }
}

// Converting between numeric types
let integer = 42
let double = 42.5

// Explicit conversions
let doubleFromInt = Double(integer)    // Safe conversion
let intFromDouble = Int(double)        // Truncates decimal part

struct FormattedNumberView: View {
    let number: Double = 1234.5678

    var body: some View {
        VStack {
            // Basic decimal formatting
            Text("\(number, specifier: "%.2f")")

            // Currency formatting
            Text(number, format: .currency(code: "USD"))

            // Percentage formatting
            Text(number/100, format: .percent)
        }
    }
}

struct AdditionExample: View {
    let a: Double
    let b: Double

    var body: some View {
        VStack(alignment: .leading) {
            Text("Addition (+)")
                .font(.headline)

            HStack {
                Text("\(a, specifier: "%.1f") + \(b, specifier: "%.1f") =")
                Text("\(a + b, specifier: "%.1f")")
                    .bold()
            }
        }
    }
}

struct SubtractionExample: View {
    let a: Double
    let b: Double

    var body: some View {
        VStack(alignment: .leading) {
            Text("Subtraction (-)")
                .font(.headline)

            HStack {
                Text("\(a, specifier: "%.1f") - \(b, specifier: "%.1f") =")
                Text("\(a - b, specifier: "%.1f")")
                    .bold()
            }
        }
    }
}

struct MultiplicationExample: View {
    let a: Double
    let b: Double

    var body: some View {
        VStack(alignment: .leading) {
            Text("Multiplication (*)")
                .font(.headline)

            HStack {
                Text("\(a, specifier: "%.1f") × \(b, specifier: "%.1f") =")
                Text("\(a * b, specifier: "%.1f")")
                    .bold()
            }
        }
    }
}

struct DivisionExample: View {
    let a: Double
    let b: Double

    var body: some View {
        VStack(alignment: .leading) {
            Text("Division (/)")
                .font(.headline)

            HStack {
                Text("\(a, specifier: "%.1f") ÷ \(b, specifier: "%.1f") =")
                if b == 0 {
                    Text("Cannot divide by zero")
                        .foregroundColor(.red)
                } else {
                    Text("\(a / b, specifier: "%.1f")")
                        .bold()
                }
            }
        }
    }
}

struct RemainderExample: View {
    let a: Double
    let b: Double

    var body: some View {
        VStack(alignment: .leading) {
            Text("Remainder (%)")
                .font(.headline)

            HStack {
                Text("\(Int(a)) % \(Int(b)) =")
                if b == 0 {
                    Text("Cannot compute remainder with zero")
                        .foregroundColor(.red)
                } else {
                    Text("\(Int(a) % Int(b))")
                        .bold()
                }
            }
        }
    }
}

struct RemainderUseCases: View {
    // State variables for interactive examples
    @State private var inputNumber: Int = 0
    @State private var selectedExample: Int = 0

    var body: some View {
        VStack(spacing: 20) {
            // Input section
            VStack(alignment: .leading) {
                Text("Enter a number:")
                    .font(.headline)
                TextField("Number", value: $inputNumber, format: .number)
                    .textFieldStyle(.roundedBorder)
                    .keyboardType(.numberPad)
            }

            // Examples Section
            GroupBox {
                VStack(alignment: .leading, spacing: 15) {
                    // 1. Even/Odd Checker
                    ExampleCard(title: "Even/Odd Check") {
                        Text("\(inputNumber) is \(inputNumber.isMultiple(of: 2) ? "even" : "odd")")
                            .foregroundColor(.secondary)
                    }

                    // 2. Circular Array Index
                    ExampleCard(title: "Circular Array Access") {
                        CircularArrayExample(number: inputNumber)
                    }

                    // 3. Time Formatting
                    ExampleCard(title: "Time Conversion") {
                        TimeExample(minutes: inputNumber)
                    }

                    // 4. Pagination
                    ExampleCard(title: "Pagination") {
                        PaginationExample(totalItems: inputNumber)
                    }
                }
            }
        }
        .padding()
    }
}

// Supporting Views
struct ExampleCard<Content: View>: View {
    let title: String
    let content: Content

    init(title: String, @ViewBuilder content: () -> Content) {
        self.title = title
        self.content = content
    }

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(title)
                .font(.headline)
            content
        }
        .padding()
        .background(Color.secondary.opacity(0.1))
        .cornerRadius(8)
    }
}

// Example Implementation Views
struct CircularArrayExample: View {
    let colors = ["Red", "Blue", "Green", "Yellow", "Purple"]
    let number: Int

    var body: some View {
        let index = number % colors.count
        HStack {
            Text("Array[\(number) % \(colors.count)] = ")
            Text(colors[index])
                .foregroundColor(.secondary)
        }
    }
}

struct TimeExample: View {
    let minutes: Int

    var body: some View {
        let hours = minutes / 60
        let remainingMinutes = minutes % 60

        Text("\(minutes) minutes = \(hours)h \(remainingMinutes)m")
            .foregroundColor(.secondary)
    }
}

struct PaginationExample: View {
    let itemsPerPage = 10
    let totalItems: Int

    var body: some View {
        let fullPages = totalItems / itemsPerPage
        let remainingItems = totalItems % itemsPerPage

        VStack(alignment: .leading) {
            Text("Total pages: \(fullPages + (remainingItems > 0 ? 1 : 0))")
            Text("Items on last page: \(remainingItems == 0 ? itemsPerPage : remainingItems)")
        }
        .foregroundColor(.secondary)
    }
}

// Examples of PEMDAS in action
let example1 = 2 + 3 * 4        // Result: 14 (not 20)
let example2 = (2 + 3) * 4      // Result: 20
let example3 = 10 - 6 / 2 + 3   // Result: 10

// Operator precedence examples
let precedence1 = 5 + 3 * 2     // 3 * 2 is evaluated first
let precedence2 = 15 - 4 + 2    // Evaluated left to right
let precedence3 = 4 * 2 + 3 * 5 // Multiplications first

var value = 10
value += 5  // value is now 15
value *= 2  // value is now 30
value -= 5  // value is now 25
value /= 5  // value is now 5

// Type inference examples
let integerValue = 42        // Inferred as Int
let doubleValue = 42.0      // Inferred as Double
let explicitDouble: Double = 42  // Explicit type annotation

// Type conversion required for mixed operations
let result = Double(integerValue) + doubleValue