#Julia Tuples

# Using parentheses
t = (1, 2, 3)
println(t)  # (1, 2, 3)

# Mixed types
t = (1, "hello", 3.14, true)
println(t)  # (1, "hello", 3.14, true)

# Single element tuple needs comma
single = (1,)     # Tuple
not_tuple = (1)   # Just number 1

# Empty tuple
empty = ()

# Assignment can omit parentheses
t = 1, 2, 3
println(t)  # (1, 2, 3)

# Function returning multiple values
function minmax(a, b)
    return a < b ? (a, b) : (b, a)
end
result = minmax(5, 3)
println(result)  # (3, 5)

t = (10, 20, 30, 40, 50)

# Access single element
println(t[1])    # 10
println(t[end])  # 50

# Range access
println(t[2:4])  # (20, 30, 40)

t = (1, 2, 3)

# Destructure to variables
a, b, c = t
println(a)  # 1
println(b)  # 2
println(c)  # 3

# Swap variables
x, y = 10, 20
x, y = y, x
println("x=$x, y=$y")  # x=20, y=10

# Ignore some values
first, _, third = (1, 2, 3)
println(first)  # 1
println(third)  # 3

# Collect remaining elements
first, rest... = (1, 2, 3, 4, 5)
println(first)  # 1
println(rest)   # (2, 3, 4, 5)

t = (1, "hello", 3.14)

# Length
println(length(t))  # 3

# Type
println(typeof(t))  # Tuple{Int64, String, Float64}

# Check if contains element
println(1 in t)       # true
println("world" in t) # false

t = (1, 2, 3)

# Attempting to modify throws error
# t[1] = 100  # ERROR: MethodError

# But if tuple contains mutable objects, the object itself can be modified
t = ([1, 2], [3, 4])
t[1][1] = 100  # This is allowed
println(t)     # ([100, 2], [3, 4])

# Using = syntax
person = (name="Alice", age=30, city="Beijing")
println(person)  # (name = "Alice", age = 30, city = "Beijing")

# Using NamedTuple constructor
nt = NamedTuple{(:x, :y)}((1, 2))
println(nt)  # (x = 1, y = 2)

# Create from variables
name = "Bob"
age = 25
person = (; name, age)  # Use variable names as field names
println(person)  # (name = "Bob", age = 25)

person = (name="Alice", age=30, city="Beijing")

# Access by name
println(person.name)  # Alice
println(person.age)   # 30

# Can also access by index
println(person[1])    # Alice

# Get all keys
println(keys(person))    # (:name, :age, :city)

# Get all values
println(values(person))  # ("Alice", 30, "Beijing")

person = (name="Alice", age=30)

# Destructure by name
(; name, age) = person
println(name)  # Alice
println(age)   # 30

# Rename
(; name => n, age => a) = person
println(n)  # Alice

t1 = (1, 2, 3)
t2 = (4, 5, 6)

# Using ... to expand
combined = (t1..., t2...)
println(combined)  # (1, 2, 3, 4, 5, 6)

nt1 = (a=1, b=2)
nt2 = (c=3, d=4)

# Merge
combined = (; nt1..., nt2...)
println(combined)  # (a = 1, b = 2, c = 3, d = 4)

# Override fields
nt1 = (a=1, b=2)
nt2 = (b=10, c=3)
combined = (; nt1..., nt2...)
println(combined)  # (a = 1, b = 10, c = 3)

t = (1, 2, 3, 4, 5)

# for loop
for x in t
    println(x)
end

# Iterate with index
for (i, x) in enumerate(t)
    println("Index $i: Value $x")
end

# Iterate named tuple
person = (name="Alice", age=30)
for (key, value) in pairs(person)
    println("$key: $value")
end

t = (1, 2, 3, 4, 5)

# Convert to array
arr = collect(t)
println(arr)  # [1, 2, 3, 4, 5]

# Array to tuple
arr = [1, 2, 3]
t = Tuple(arr)
println(t)  # (1, 2, 3)

# Named tuple to dictionary
person = (name="Alice", age=30)
d = Dict(pairs(person))
println(d)  # Dict(:name => "Alice", :age => 30)

function divrem_custom(a, b)
    return (a ÷ b, a % b)
end

quotient, remainder = divrem_custom(17, 5)
println("Quotient: $quotient, Remainder: $remainder")  # Quotient: 3, Remainder: 2

# Using splatting to expand tuple as arguments
function add3(a, b, c)
    return a + b + c
end

args = (1, 2, 3)
result = add3(args...)
println(result)  # 6

# Variadic arguments as tuple
function show_all(args...)
    println("Received $(length(args)) arguments")
    for arg in args
        println("  - $arg")
    end
end

show_all(1, 2, 3, "hello")

t1 = (1, 2, 3)
t2 = (1, 2, 3)
t3 = (1, 2, 4)

# Equality comparison
println(t1 == t2)  # true
println(t1 == t3)  # false

# Size comparison (lexicographic)
println(t1 < t3)   # true (because 3 < 4)
println((1, 2) < (1, 2, 3))  # true (shorter is smaller)

function analyze(data)
    n = length(data)
    total = sum(data)
    avg = total / n
    return (count=n, sum=total, average=avg)
end

result = analyze([1, 2, 3, 4, 5])
println(result.average)  # 3.0

# Tuples can be dictionary keys
locations = Dict{Tuple{Int,Int}, String}()
locations[(0, 0)] = "Origin"
locations[(1, 2)] = "Point A"

println(locations[(0, 0)])  # Origin

# Swap variables
a, b = 1, 2
a, b = b, a

# Simultaneous assignment
x, y, z = 1, 2, 3

config = (
    host = "localhost",
    port = 8080,
    debug = true,
    timeout = 30
)

println("Server: $(config.host):$(config.port)")

# Tuple: type known at compile time
t = (1, "hello", 3.14)
println(typeof(t))  # Tuple{Int64, String, Float64}

# Array: uniform element type
arr = [1, 2, 3]
println(typeof(arr))  # Vector{Int64}