let x = 5
let y = 10
let name = "Victoria"
let isActive = true

let x = 5
x = 10  // reassignment

const PI = 3.14159
const MAX_SIZE = 100
const APP_NAME = "Victoria Lang"

print(PI)       // 3.14159

// Attempting to reassign a const will cause an error:
PI = 3.0        // ERROR: cannot reassign constant variable: PI

let x:int = 42
let name:string = "Victoria"
let pi:float = 3.14159
let isReady:bool = true

let x:int = "hello"  // ERROR: type mismatch: cannot assign string to variable of type int

let typed:int = 42     // typed variable
let untyped = "hello"  // untyped (dynamic) variable

#make MAX_SIZE 1000
#make MOD 1000000007
#make INF 999999999
#make EPSILON 0.00001

// Use in your code
let arr = []
for i in 0..MAX_SIZE {
    arr = push(arr, 0)
}

// Great for competitive programming
let result = (a * b) % MOD

// Basic enum
enum Color {
    RED,        // 0
    GREEN,      // 1
    BLUE        // 2
}

// Enum with explicit values
enum HttpStatus {
    OK = 200,
    NOT_FOUND = 404,
    SERVER_ERROR = 500
}

// Using enums
let myColor = Color.RED
print(myColor)           // Color.RED

// Enums in switch statements
switch (myColor) {
    case Color.RED: {
        print("It's red!")
    }
    case Color.GREEN: {
        print("It's green!")
    }
    case Color.BLUE: {
        print("It's blue!")
    }
}

// Enum for graph algorithms
enum NodeState {
    UNVISITED,
    VISITING,
    VISITED
}

let states = []
for i in 0..n {
    states = push(states, NodeState.UNVISITED)
}

let ch = 'A'           // Character literal
let newline = '\n'     // Escape sequences supported
let tab = '\t'

// Get ASCII/Unicode value
let ascii = ord('A')   // 65
print(ascii)

// Convert number to character
let letter = chr(65)   // "A"
print(letter)

// Character functions for DSA
if (isDigit(ch)) {
    print("It's a digit!")
}

if (isLetter(ch)) {
    print("It's a letter!")
}

// Useful for string parsing in algorithms
let str = "abc123"
for i in 0..len(str) {
    let c = str[i]
    if (isDigit(c)) {
        print("Found digit: ${c}")
    }
}

let name = "Victoria"
let version = 1
print("Hello from ${name} version ${version}!")
// Output: Hello from Victoria version 1!

let a = 2
let b = 3
print("${a} + ${b} = ${a + b}")
// Output: 2 + 3 = 5

let poem = `Roses are red,
Violets are blue,
Victoria is awesome,
And so are you!`

if (x > 0 && x < 10) {
    print("x is between 0 and 10")
}

if (name == "admin" || isSuper) {
    print("Access granted")
}

let x = 10
x += 5   // x is now 15
x -= 3   // x is now 12
x *= 2   // x is now 24
x /= 4   // x is now 6
x %= 4   // x is now 2

let x = 5
print(++x)  // 6 (increments first, then returns)
print(x++)  // 6 (returns first, then increments)
print(x)    // 7

let result = condition ? valueIfTrue : valueIfFalse

let age = 20
let status = age >= 18 ? "adult" : "minor"
print(status)  // "adult"

for i in 0..5 {
    print(i)  // 0, 1, 2, 3, 4
}

let x = 10
if (x > 5) {
    print("x is greater than 5")
} else if (x == 5) {
    print("x equals 5")
} else {
    print("x is less than 5")
}

let day = 3
switch (day) {
    case 1: {
        print("Monday")
    }
    case 2: {
        print("Tuesday")
    }
    case 3: {
        print("Wednesday")
    }
    default: {
        print("Other day")
    }
}

let i = 0
while (i < 5) {
    print(i)
    i++
}

for (let i = 0; i < 5; i++) {
    print(i)
}

let arr = [1, 2, 3]
for x in arr {
    print(x)
}

let fruits = ["apple", "banana", "cherry"]
for i, fruit in fruits {
    print("${i}: ${fruit}")
}
// Output:
// 0: apple
// 1: banana
// 2: cherry

// Using range operator
for i in 0..5 {
    print(i)  // 0, 1, 2, 3, 4
}

// Using range function
for i in range(5) {
    print(i)  // 0, 1, 2, 3, 4
}

for i in range(2, 8) {
    print(i)  // 2, 3, 4, 5, 6, 7
}

for i in range(0, 10, 2) {
    print(i)  // 0, 2, 4, 6, 8
}

// Break exits the loop
for i in 0..10 {
    if (i == 5) {
        break
    }
    print(i)  // 0, 1, 2, 3, 4
}

// Continue skips to next iteration
for i in 0..5 {
    if (i == 2) {
        continue
    }
    print(i)  // 0, 1, 3, 4
}

define add(x, y) {
    return x + y
}

let result = add(5, 10)
print(result)  // 15

let multiply = define(x, y) {
    return x * y
}

print(multiply(3, 4))  // 12

// Function with typed parameters
define add(a:int, b:int) -> int {
    return a + b
}

// Multiple return values with different types
define greet(name:string, age:int) -> string {
    return "Hello, " + name + "! You are " + string(age) + " years old."
}

// Function with any type (accepts anything)
define printValue(val:any) -> void {
    print("Value:", val)
}

define add(a:int, b:int) -> int {
    return a + b
}

add(5, 3)        // OK - both arguments are int
add("hello", 5)  // ERROR: type mismatch for parameter 'a': expected int, got string

define getNumber() -> int {
    return "not a number"  // ERROR: return type mismatch: expected int, got string
}

define log(message:string, data) {
    print(message, data)
}

define applyTwice(f, x) {
    return f(f(x))
}

let double = define(n) { n * 2 }
print(applyTwice(double, 5))  // 20

// Single parameter lambda
let double = x => x * 2
print(double(5))  // 10

// Multiple parameters (use parentheses)
let add = (x, y) => x + y
print(add(3, 4))  // 7

// No parameters
let getAnswer = () => 42
print(getAnswer())  // 42

let numbers = [1, 2, 3, 4, 5]

// Map: transform each element
let doubled = map(numbers, x => x * 2)
print(doubled)  // [2, 4, 6, 8, 10]

// Filter: keep elements matching condition
let evens = filter(numbers, x => x % 2 == 0)
print(evens)  // [2, 4]

// Reduce: accumulate values
let sum = reduce(numbers, (acc, x) => acc + x, 0)
print(sum)  // 15

// Chain operations
let result = map(filter(numbers, x => x > 2), x => x * 10)
print(result)  // [30, 40, 50]

let arr = [1, 2, 3, "four", true]
print(arr[0])    // 1
print(len(arr))  // 5

// Array methods
let nums = [1, 2, 3, 4, 5]

// map - transform each element
let doubled = map(nums, define(x) { x * 2 })
print(doubled)  // [2, 4, 6, 8, 10]

// filter - keep elements matching condition
let evens = filter(nums, define(x) { x % 2 == 0 })
print(evens)  // [2, 4]

// reduce - accumulate values
let sum = reduce(nums, define(acc, x) { acc + x }, 0)
print(sum)  // 15

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// Get elements from index 2 to 5 (exclusive)
print(arr[2:5])   // [3, 4, 5]

// Get elements from start to index 3
print(arr[:3])    // [1, 2, 3]

// Get elements from index 5 to end
print(arr[5:])    // [6, 7, 8, 9, 10]

// Negative indexing (from end)
print(arr[-3:])   // [8, 9, 10]
print(arr[:-2])   // [1, 2, 3, 4, 5, 6, 7, 8]

// String slicing also works
let str = "Hello, World!"
print(str[0:5])   // "Hello"
print(str[7:])    // "World!"
print(str[-6:])   // "World!"

let arr1 = [1, 2, 3]
let arr2 = [4, 5, 6]

// Merge arrays
let merged = [...arr1, ...arr2]
print(merged)     // [1, 2, 3, 4, 5, 6]

// Add elements around spread
let extended = [0, ...arr1, 99, ...arr2, 100]
print(extended)   // [0, 1, 2, 3, 99, 4, 5, 6, 100]

// Copy an array
let original = [10, 20, 30]
let copy = [...original]
print(copy)       // [10, 20, 30]

// Combine with slicing
let arr = [1, 2, 3, 4, 5]
let combined = [...arr[:2], ...arr[3:]]
print(combined)   // [1, 2, 4, 5]

let person = {
    "name": "Alice",
    "age": 30,
    "city": "Wonderland"
}

print(person["name"])  // Alice

// Get all keys
print(keys(person))    // ["name", "age", "city"]

// Get all values
print(values(person))  // ["Alice", 30, "Wonderland"]

struct Person {
    name
    age
}

// Define a method for the Person struct
define Person.greet() {
    print("Hello, my name is ${self.name}")
}

define Person.birthday() {
    self.age = self.age + 1
    print("Happy birthday! Now ${self.age} years old.")
}

// Instantiate a struct
let p = Person {
    name: "Bob",
    age: 25
}

p.greet()     // Hello, my name is Bob
p.birthday()  // Happy birthday! Now 26 years old.

include "net"        // Built-in network module
include "os"         // Built-in OS module  
include "math"       // Built-in math module
include "json"       // Built-in JSON module
include "time"       // Built-in time/date module
include "path"       // Built-in path module
include "mylib"      // Local file (mylib.vc)

include ("os", "math", "json", "time", "path")

let version = "1.0.0"
let add = define(a, b) { return a + b }

include "mylib"
print(mylib.version)
print(mylib.add(1, 2))

include "os"

// File operations
os.writeFile("test.txt", "Hello Victoria!")
let content = os.readFile("test.txt")
print(os.exists("test.txt")) // true
os.remove("test.txt")

// Directory operations
os.mkdir("data/logs")
let files = os.readDir(".")
os.chdir("data")
print(os.getwd())

// Environment and System
print(os.env("PATH"))
os.env("MY_VAR", "123")
print(os.platform) // "windows", "linux", etc.
print(os.arch)     // "amd64", "arm64", etc.
print(os.pid)      // Current process ID
print(os.hostname())
print(os.user().username)

// Command Execution
let output = os.exec("echo", "Hello from Shell")
print(output)

// Process
os.kill(1234) // Kill process by PID
os.exit(0)

include "path"

let fullPath = path.join("data", "users", "config.json")
print(path.base(fullPath)) // "config.json"
print(path.dir(fullPath))  // "data/users"
print(path.ext(fullPath))  // ".json"
print(path.abs("."))       // Absolute path to current dir
print(path.isAbs("/etc"))  // true (on Unix)

include "math"

// Constants
print(math.pi)   // 3.141592653589793
print(math.e)    // 2.718281828459045

// Basic functions
print(math.abs(-5))      // 5
print(math.sqrt(16))     // 4
print(math.pow(2, 10))   // 1024

// Trigonometric functions
print(math.sin(0))       // 0
print(math.cos(0))       // 1
print(math.tan(0))       // 0

// Rounding functions
print(math.floor(3.7))   // 3
print(math.ceil(3.2))    // 4
print(math.round(3.5))   // 4

// Min/Max (accepts multiple arguments)
print(math.min(5, 3, 8, 1))   // 1
print(math.max(5, 3, 8, 1))   // 8

// Random numbers
print(math.random())          // Random float 0-1
print(math.random(10))        // Random int 0-9
print(math.random(1, 6))      // Random int 1-6 (dice roll)

// Logarithmic functions
print(math.log(2.718281828))  // ~1 (natural log)
print(math.log10(100))        // 2

include "json"

// Parse JSON string to Victoria object
let jsonStr = `{"name": "Victoria", "version": 1.0}`
let obj = json.parse(jsonStr)
print(obj["name"])     // Victoria
print(obj["version"])  // 1

// Stringify Victoria object to JSON
let data = {
    "language": "Victoria",
    "year": 2024,
    "active": true,
    "tags": ["fast", "simple"]
}
print(json.stringify(data))
// {"active":true,"language":"Victoria","tags":["fast","simple"],"year":2024}

// Pretty print with indentation
print(json.stringify(data, 2))
// {
//   "active": true,
//   "language": "Victoria",
//   ...
// }

// Validate JSON string
print(json.valid(`{"valid": true}`))  // true
print(json.valid("not json"))         // false

include "time"

// Get current timestamp (Unix seconds)
let now = time.now()
print(now)  // e.g., 1702400000

// Get current timestamp in milliseconds
let nowMs = time.nowMs()
print(nowMs)  // e.g., 1702400000123

// Format timestamp to string
print(time.format(now))                    // "2024-12-12 10:30:00"
print(time.format(now, "YYYY-MM-DD"))      // "2024-12-12"
print(time.format(now, "HH:mm:ss"))        // "10:30:00"

// Parse date string to timestamp
let ts = time.parse("2024-12-25 10:30:00")
print(ts)  // Unix timestamp

// Get date/time components
print(time.year(now))     // 2024
print(time.month(now))    // 12
print(time.day(now))      // 12
print(time.hour(now))     // 10
print(time.minute(now))   // 30
print(time.second(now))   // 0
print(time.weekday(now))  // 0-6 (0=Sunday)

// Quick date/time strings
print(time.date())        // "2024-12-12"
print(time.time())        // "10:30:00"
print(time.date(now))     // Date of timestamp
print(time.time(now))     // Time of timestamp

// Sleep (pause execution)
time.sleep(1000)  // Sleep for 1000 milliseconds (1 second)

include "net"

// HTTP Client
let resp = net.get("https://api.github.com")
print(resp.status)
print(resp.body)

// Generic Request
let postResp = net.request("POST", "https://example.com/api", `{"id": 1}`, {"Content-Type": "application/json"})

// DNS and Interfaces
print(net.lookupHost("google.com"))
print(net.interfaces()[0].mac)

// HTTP Server (Simple)
net.listen(8080, define(req) {
    return "Hello from Victoria!"
})

// HTTP Server (with Routing)
net.serve(8080, {
    "/": define(req) { return "Home" },
    "/api": define(req) { 
        return {
            "status": 200,
            "body": `{"status": "ok"}`,
            "headers": {"Content-Type": "application/json"}
        }
    }
})

// TCP Client
let conn = net.dial("localhost", 9000)
conn.write("Hello TCP\n")
print(conn.read())
conn.close()

// TCP Server
net.listenTcp(9000, fn(conn) {
    let msg = conn.read()
    print("Received: " + msg)
    conn.write("Echo: " + msg + "\n")
    conn.close()
})

// UDP Server
net.listenUdp(9001, fn(packet) {
    print("From " + packet.remote + ": " + packet.data)
})

// Example: Count digits and letters in a string
let str = "Hello123World456"
let digits = 0
let letters = 0

for i in 0..len(str) {
    let c = str[i]
    if (isDigit(c)) {
        digits++
    }
    if (isLetter(c)) {
        letters++
    }
}
print("Digits: ${digits}, Letters: ${letters}")
// Output: Digits: 6, Letters: 10

// Example: Convert string to uppercase manually
define toUpperStr(s) {
    let result = ""
    for i in 0..len(s) {
        let c = s[i]
        if (ord(c) >= ord('a') && ord(c) <= ord('z')) {
            result = result + chr(ord(c) - 32)
        } else {
            result = result + c
        }
    }
    return result
}
print(toUpperStr("hello"))  // "HELLO"

range(5)        // [0, 1, 2, 3, 4]
range(2, 7)     // [2, 3, 4, 5, 6]
range(0, 10, 2) // [0, 2, 4, 6, 8]
range(10, 0, -1) // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

try {
    let result = riskyOperation()
    print(result)
} catch (err) {
    print("Error occurred: ${err}")
}

error[E0002]: identifier not found: myVariable
 --> script.vc:5:12
  |
4 | let x = 10
5 | let y = myVariable + x
  |         ^^^^^^^^^^ identifier not found: myVariable
6 |
  |
  = help: did you mean to declare 'myVariable' with 'let myVariable = ...'?

error: type mismatch: STRING + INTEGER
 --> script.vc:3:20
  |
2 | let greeting = "Hello"
3 | let result = greeting + 42
  |                      ^ type mismatch: STRING + INTEGER
4 |
  |
  = note: Victoria is a dynamically typed language, but operators require compatible types
  = help: use string() to convert integers to strings, or int() to convert strings to integers

error[E0004]: expected '=' but found 'EOF'
 --> script.vc:2:1
  |
1 | let x
2 |
  | ^ expected '=' here
  |
  = note: reached end of file unexpectedly
  = help: variable declarations require an initial value: let name = value

// Competitive programming essentials
#make MOD 1000000007        // Most common modulo
#make MOD2 998244353        // NTT-friendly prime
#make INF 999999999         // Infinity for shortest path
#make NINF -999999999       // Negative infinity
#make MAXN 100005           // Common array size
#make EPSILON 0.000001      // Float comparison threshold

// Count character frequency (classic interview question)
define countFrequency(s) {
    let freq = {}
    for i in 0..len(s) {
        let c = s[i]
        if (freq[c] == null) {
            freq[c] = 1
        } else {
            freq[c] = freq[c] + 1
        }
    }
    return freq
}

// Usage
let freq = countFrequency("mississippi")
print(freq)  // {m: 1, i: 4, s: 4, p: 2}

// Check if palindrome
define isPalindrome(s) {
    let left = 0
    let right = len(s) - 1
    
    while (left < right) {
        if (toLower(s[left]) != toLower(s[right])) {
            return false
        }
        left = left + 1
        right = right - 1
    }
    return true
}

// Two Sum (sorted array)
define twoSum(arr, target) {
    let left = 0
    let right = len(arr) - 1
    
    while (left < right) {
        let sum = arr[left] + arr[right]
        if (sum == target) {
            return [left, right]
        } else if (sum < target) {
            left = left + 1
        } else {
            right = right - 1
        }
    }
    return []
}

define binarySearch(arr, target) {
    let left = 0
    let right = len(arr) - 1
    
    while (left <= right) {
        // Use this form to avoid integer overflow
        let mid = left + (right - left) / 2
        
        if (arr[mid] == target) {
            return mid
        } else if (arr[mid] < target) {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return -1  // Not found
}

// Find lower bound (first >= target)
define lowerBound(arr, target) {
    let left = 0
    let right = len(arr)
    
    while (left < right) {
        let mid = left + (right - left) / 2
        if (arr[mid] < target) {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}

// Fibonacci with memoization
let fibMemo = {}

define fib(n) {
    if (n <= 1) {
        return n
    }
    
    // Check cache first
    if (fibMemo[n] != null) {
        return fibMemo[n]
    }
    
    // Compute and cache
    let result = fib(n - 1) + fib(n - 2)
    fibMemo[n] = result
    return result
}

// Now fib(40) runs instantly instead of taking seconds
print(fib(40))  // 102334155

// Perfect for cycle detection, topological sort
enum NodeState {
    UNVISITED,   // 0 - Not yet visited
    VISITING,    // 1 - Currently in DFS stack
    VISITED      // 2 - Completely processed
}

define hasCycle(graph, node, states) {
    if (states[node] == NodeState.VISITING) {
        return true  // Back edge found = cycle!
    }
    if (states[node] == NodeState.VISITED) {
        return false  // Already processed
    }
    
    states[node] = NodeState.VISITING
    
    for neighbor in graph[node] {
        if (hasCycle(graph, neighbor, states)) {
            return true
        }
    }
    
    states[node] = NodeState.VISITED
    return false
}

define mergeSort(arr) {
    if (len(arr) <= 1) {
        return arr
    }
    
    let mid = len(arr) / 2
    let left = mergeSort(arr[:mid])    // Array slicing!
    let right = mergeSort(arr[mid:])   // So clean!
    
    return merge(left, right)
}

define merge(left, right) {
    let result = []
    let i = 0
    let j = 0
    
    while (i < len(left) && j < len(right)) {
        if (left[i] <= right[j]) {
            result = push(result, left[i])
            i = i + 1
        } else {
            result = push(result, right[j])
            j = j + 1
        }
    }
    
    // Add remaining elements
    while (i < len(left)) {
        result = push(result, left[i])
        i = i + 1
    }
    while (j < len(right)) {
        result = push(result, right[j])
        j = j + 1
    }
    
    return result
}

#make MOD 1000000007

// Greatest Common Divisor (Euclidean algorithm)
define gcd(a, b) {
    if (b == 0) {
        return a
    }
    return gcd(b, a % b)
}

// Least Common Multiple
define lcm(a, b) {
    return (a / gcd(a, b)) * b
}

// Modular exponentiation (a^b % MOD)
define modPow(base, exp, mod) {
    let result = 1
    base = base % mod
    
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod
        }
        exp = exp / 2
        base = (base * base) % mod
    }
    return result
}

// Sieve of Eratosthenes
define sieve(n) {
    let isPrime = []
    for i in 0..n+1 {
        isPrime = push(isPrime, true)
    }
    isPrime[0] = false
    isPrime[1] = false
    
    for i in 2..n+1 {
        if (isPrime[i]) {
            let j = i * i
            while (j <= n) {
                isPrime[j] = false
                j = j + i
            }
        }
    }
    
    let primes = []
    for i in 0..n+1 {
        if (isPrime[i]) {
            primes = push(primes, i)
        }
    }
    return primes
}

// Parse integers from a string
define parseNumbers(s) {
    let numbers = []
    let current = ""
    
    for i in 0..len(s) {
        let c = s[i]
        if (isDigit(c)) {
            current = current + c
        } else {
            if (len(current) > 0) {
                numbers = push(numbers, int(current))
                current = ""
            }
        }
    }
    
    // Don't forget the last number
    if (len(current) > 0) {
        numbers = push(numbers, int(current))
    }
    
    return numbers
}

// Validate parentheses
define isValidParentheses(s) {
    let count = 0
    for i in 0..len(s) {
        let c = s[i]
        if (c == "(") {
            count = count + 1
        } else if (c == ")") {
            count = count - 1
            if (count < 0) {
                return false
            }
        }
    }
    return count == 0
}

// WRONG: This misses the last element
for i in 0..len(arr) - 1 { }

// CORRECT: 0..n means 0 to n-1, which is all indices
for i in 0..len(arr) { }

// WRONG: May overflow for large values
let result = a * b

// CORRECT: Use modular arithmetic
#make MOD 1000000007
let result = ((a % MOD) * (b % MOD)) % MOD

// WRONG: No base case = infinite recursion
define fib(n) {
    return fib(n-1) + fib(n-2)
}

// CORRECT: Always have a base case
define fib(n) {
    if (n <= 1) { return n }
    return fib(n-1) + fib(n-2)
}

// WRONG: May cause infinite loop
let mid = (left + right) / 2

// CORRECT: Prevents overflow and handles edge cases
let mid = left + (right - left) / 2

// WRONG: May crash on empty array
return arr[0]

// CORRECT: Always check first
if (len(arr) == 0) {
    return null
}
return arr[0]