example.smash

let x = [1, 2, 3];
const y = [true, false, false, true];
};

print("age:", user.age);

for (let i of x) {
	print(i);
}

// Iterate over object properties with for...in loop
for (let val in user) {
    print(val, user[val]);
}


for (let x of y) {
    if (x) {
        print("true");
        continue;
    } else {
        print("false");
    }
}

// Sleep function using Promise with setTimeout
async fn sleep(ms) {
    print("Sleeping...");
    return new Promise((resolve, reject) => {
        setTimeout(resolve, ms);
    });
}

// Test async function
async fn test() {
    print("Starting test");
    const result = await sleep(1000);
    print("Finished sleeping");
    return result;
}

// Call the async function
print("Before await");
const result = await test();
print("After await");
print("Result:");
print(result);

let message = "Hello, SmashLang!";
let year = 2025;
let pi = 3.14;
let active = true;
let active2 = false;

if (active) {
    print(pi);
}

if (!active2) {
    print("not active", pi);
}

// Using a string-based approach for regex patterns
let pattern = "smash.*";

print(message);

// Simple Promise test
print("Promise test:");

// Create a function that returns a promise
fn createPromise() {
    return new Promise((resolve, reject) => {
        // Resolve after a delay
        setTimeout(() => {
            resolve("Promise resolved!");
        }, 1000);
    });
}

// Create a function to handle the Promise result
fn handlePromise(result) {
    print("Promise result:", result);
    return "Processed: " + result;
}

// Create a function to handle errors
fn handleError(error) {
    print("Promise error:", error);
}

// Use the Promise
const promiseResult = createPromise();

// Add handlers manually
promiseResult.then(handlePromise);
promiseResult.onCatch(handleError);

// Example of try/catch/finally blocks
print("Try/Catch/Finally example:");
try {
    print("Inside try block");
    // Throw an error
    throw new Error("Something went wrong");
    print("This will not be executed");
} catch (error) {
    print("Inside catch block");
    print("Error message: " + error);
} finally {
    print("Inside finally block - this always executes");
}

// Example of fetch with Promise chaining
print("Fetch example with Promise chaining:");

// Using variable assignment for method chaining (recommended approach)
const fetchTodoResult = fetch("https://jsonplaceholder.typicode.com/todos/1");

const jsonTodoResult = fetchTodoResult.then((response) => {
    print("Todo response status: " + response.status);
    return response.json();
});

const processedTodoResult = jsonTodoResult.then((data) => {
    print("Todo title: " + data.title);
    print("Todo completed: " + data.completed);
    return data;
});

processedTodoResult.onCatch((error) => {
    print("Fetch todo error: " + error);
});

// Example of fetching user data
print("Fetching user data:");
const fetchUserResult = fetch("https://jsonplaceholder.typicode.com/users/1");

const jsonUserResult = fetchUserResult.then((response) => {
    if (!response.ok) {
        throw new Error("Network response was not ok: " + response.status);
    }
    return response.json();
});

const processedUserResult = jsonUserResult.then((userData) => {
    print("User name: " + userData.name);
    print("User email: " + userData.email);
    print("User company: " + userData.company.name);
    return userData;
});

processedUserResult.onCatch((error) => {
    print("Fetch user error: " + error);
});

// Example of fetching posts with async/await
print("Fetching posts with async/await:");

async fn fetchPosts() {
    try {
        const response = await fetch("https://jsonplaceholder.typicode.com/posts?userId=1");
        if (!response.ok) {
            throw new Error("Failed to fetch posts: " + response.status);
        }
        
        const posts = await response.json();
        print("Number of posts: " + posts.length);
        
        // Display the first post
        if (posts.length > 0) {
            const firstPost = posts[0];
            print("First post title: " + firstPost.title);
            print("First post body: " + firstPost.body);
        }
        
        return posts;
    } catch (error) {
        print("Error fetching posts: " + error);
        return [];
    }
}

// Call the async function to fetch posts
const postsResult = await fetchPosts();

print(postsResult);

// Simple async/await test
print("Async/await test:");

// Helper function that returns a promise
fn createDelayPromise(ms, value) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(value);
        }, ms);
    });
}

// Define an async function
async fn processAsync() {
    try {
        print("Starting async operation...");
        
        // Use await with our delay function
        const result1 = await createDelayPromise(500, "First result");
        print("Got first result:", result1);
        
        // Chain another async operation
        const result2 = await createDelayPromise(500, "Second result: " + result1);
        print("Got second result:", result2);
        
        return "Completed: " + result2;
    } catch (error) {
        print("Async error:", error);
        return null;
    }
}

// Call the async function
print("Before calling async function");
const asyncResult = await processAsync();
print("After async function");
print("Final result:", asyncResult);