Advanced Programming

// O(1) - Constant Time (Always 1 step)
function getFirstItem(array) {
    return array[0];  // Instant, no matter how big the array!
}

// O(n) - Linear Time (Steps = items)
function findMax(array) {
    let max = array[0];
    for (let i = 0; i < array.length; i++) {
        if (array[i] > max) max = array[i];  // Check each item once
    }
    return max;
}

// O(n²) - Quadratic Time (Steps = items × items)
function findDuplicates(array) {
    for (let i = 0; i < array.length; i++) {
        for (let j = 0; j < array.length; j++) {
            // Nested loops = slower!
        }
    }
}

// Linear Search - O(n) - Check one by one
function linearSearch(array, target) {
    for (let i = 0; i < array.length; i++) {
        if (array[i] === target) {
            return i;  // Found it at index i!
        }
    }
    return -1;  // Not found
}

// Binary Search - O(log n) - Divide and conquer!
// ONLY works on sorted arrays!
function binarySearch(array, target) {
    let left = 0;
    let right = array.length - 1;
    
    while (left <= right) {
        let mid = Math.floor((left + right) / 2);
        
        if (array[mid] === target) {
            return mid;  // Found it!
        } else if (array[mid] < target) {
            left = mid + 1;  // Target is in right half
        } else {
            right = mid - 1;  // Target is in left half
        }
    }
    
    return -1;  // Not found
}

// Bubble Sort - Simple but slow
function bubbleSort(array) {
    let n = array.length;
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n - i - 1; j++) {
            // If current is bigger than next, swap them
            if (array[j] > array[j + 1]) {
                [array[j], array[j + 1]] = [array[j + 1], array[j]];
            }
        }
    }
    return array;
}

// Selection Sort - Find smallest, put first
function selectionSort(array) {
    for (let i = 0; i < array.length; i++) {
        let minIndex = i;
        // Find the smallest in remaining array
        for (let j = i + 1; j < array.length; j++) {
            if (array[j] < array[minIndex]) {
                minIndex = j;
            }
        }
        // Swap with first unsorted position
        [array[i], array[minIndex]] = [array[minIndex], array[i]];
    }
    return array;
}

// Factorial: n! = n × (n-1) × (n-2) × ... × 1
function factorial(n) {
    // Base case: 1! = 1, 0! = 1
    if (n <= 1) return 1;
    
    // Recursive case: n! = n × (n-1)!
    return n * factorial(n - 1);
}

// Sum of array using recursion
function sumArray(array, index = 0) {
    // Base case: reached end of array
    if (index >= array.length) return 0;
    
    // Recursive case: current + sum of rest
    return array[index] + sumArray(array, index + 1);
}

// Countdown using recursion
function countdown(n) {
    if (n <= 0) {
        console.log("Blast off! 🚀");
        return;
    }
    console.log(n);
    countdown(n - 1);  // Call with smaller number
}

countdown(5);  // 5, 4, 3, 2, 1, Blast off!

/*
PHASE 1 - PLANNING: "Build a 2D platformer game"
- Target: Kids aged 8-12
- Platform: Web browser
- Timeline: 6 months, 3 developers

PHASE 2 - ANALYSIS:
- Tech stack: HTML5 Canvas + JavaScript
- Risks: Browser compatibility, mobile performance

PHASE 3 - DESIGN:
- Character animations: Running, jumping, attacking
- 10 levels with increasing difficulty
- Database for high scores

PHASE 4 - DEVELOPMENT:
- Programmers build game engine
- Artists create sprites
- Sound designers create audio

PHASE 5 - TESTING:
- Check all browsers
- Find and fix bugs
- Security testing

PHASE 6 - DEPLOYMENT:
- Upload to web server
- Create landing page
- Social media announcement

PHASE 7 - MAINTENANCE:
- Fix bugs found by players
- Add new features
- Improve stability
*/

// AGILE SPRINT: Building a Todo App (2 weeks)

/*
SPRINT PLANNING (Day 1):
- Pick tasks from backlog
- Goal: "Add reminders and categories"
- Timeline: 2 weeks

DAILY STANDUPS (Every morning, 15 min):
Dev 1: "Built reminder UI yesterday, connecting DB today"
Dev 2: "Fixed category bug, testing notifications today"
Dev 3: "Blocked - need help with timezone"

SPRINT REVIEW (Day 10):
- Demo to stakeholders
- "Users can now set reminders!"
- Feedback: "Add snooze feature next sprint"

SPRINT RETROSPECTIVE:
- Went well: Testing caught bugs early
- Improve: Better timezone handling
- Action: Add timezone library

NEXT SPRINT:
- Snooze feature
- Timezone improvements
*/

// MODEL - Manages data
class UserModel {
    constructor() {
        this.users = [];
    }
    
    addUser(name, email) {
        this.users.push({ id: Date.now(), name, email });
    }
    
    getUser(id) {
        return this.users.find(u => u.id === id);
    }
}

// VIEW - Manages display
class UserView {
    displayUser(user) {
        console.log(`User: ${user.name}`);
    }
    
    displayError(msg) {
        console.error(`Error: ${msg}`);
    }
}

// CONTROLLER - Handles logic
class UserController {
    constructor(model, view) {
        this.model = model;
        this.view = view;
    }
    
    createUser(name, email) {
        if (!name || !email) {
            this.view.displayError("Required!");
            return;
        }
        this.model.addUser(name, email);
        this.view.displayUser({ name, email });
    }
}

// SINGLETON - Only one database connection allowed!
class Database {
    constructor() {
        if (Database.instance) {
            return Database.instance;  // Return existing instance
        }
        this.connection = "Connected!";
        Database.instance = this;
    }
    
    query(sql) {
        console.log(`Running: ${sql}`);
    }
}

const db1 = new Database();
const db2 = new Database();
console.log(db1 === db2);  // true - Same object!

// FACTORY - Creates different types of objects
class NotificationFactory {
    static create(type, message) {
        switch(type) {
            case "email":
                return new EmailNotification(message);
            case "sms":
                return new SMSNotification(message);
            case "push":
                return new PushNotification(message);
        }
    }
}

const notif = NotificationFactory.create("email", "Hello!");
notif.send();  // Sends email notification

// OBSERVER PATTERN - YouTube Subscription System

class YouTubeChannel {
    constructor(name) {
        this.name = name;
        this.subscribers = [];
    }
    
    subscribe(user) {
        this.subscribers.push(user);
        console.log(`${user.name} subscribed to ${this.name}`);
    }
    
    uploadVideo(videoTitle) {
        console.log(`\n🎥 New video: "${videoTitle}" on ${this.name}`);
        // Notify ALL subscribers!
        this.subscribers.forEach(user => {
            user.notify(this.name, videoTitle);
        });
    }
}

class Subscriber {
    constructor(name) {
        this.name = name;
    }
    
    notify(channel, video) {
        console.log(`🔔 ${this.name}: New video "${video}" from ${channel}`);
    }
}

// Usage
const techChannel = new YouTubeChannel("Code Masters");
const alice = new Subscriber("Alice");
const bob = new Subscriber("Bob");

techChannel.subscribe(alice);
techChannel.subscribe(bob);
techChannel.uploadVideo("Learn JavaScript in 10 Minutes!");

// Output:
// Alice subscribed to Code Masters
// Bob subscribed to Code Masters
// 🎥 New video: "Learn JavaScript..." on Code Masters
// 🔔 Alice: New video from Code Masters
// 🔔 Bob: New video from Code Masters

-- SELECT - Get data from database
SELECT * FROM Users;                    -- Get ALL users
SELECT name, email FROM Users;          -- Get only name and email
SELECT * FROM Users WHERE id = 1;       -- Get user with id=1 (Alice)

-- INSERT - Add new data
INSERT INTO Users (name, email) 
VALUES ('David', 'david@email.com');

-- UPDATE - Change existing data
UPDATE Users 
SET email = 'alice.new@email.com' 
WHERE id = 1;

-- DELETE - Remove data
DELETE FROM Users WHERE id = 3;       -- Delete Carol

-- JOIN - Combine tables
SELECT Users.name, Orders.product
FROM Users
JOIN Orders ON Users.id = Orders.user_id;
-- Result: Alice | Laptop
--         Alice | Keyboard
--         Bob   | Mouse

// Fetch data from an API (like getting a menu)
async function getUsers() {
    try {
        const response = await fetch('https://api.example.com/users');
        const data = await response.json();
        console.log(data);  // Array of user objects
    } catch (error) {
        console.error("Error fetching users:", error);
    }
}

// POST - Create new user (like placing an order)
async function createUser(name, email) {
    const response = await fetch('https://api.example.com/users', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ name, email })
    });
    return await response.json();
}

// JSON - JavaScript Object Notation (data format)
const userData = {
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com",
    "hobbies": ["coding", "reading"]  // Can have arrays!
};

# Setup a new repository
git init                          # Initialize git in current folder
git clone https://github.com/user/repo.git  # Download existing repo

# Daily workflow
git status                        # Check what changed
git add filename.js               # Stage specific file
git add .                         # Stage all changes
git commit -m "Added new feature" # Save snapshot with message
git push origin main              # Upload to GitHub

# Collaboration
git pull origin main              # Download latest changes
git branch feature-login          # Create new branch
git checkout feature-login        # Switch to branch
git merge feature-login           # Combine branches

# Undo mistakes
git log                           # See commit history
git checkout -- filename.js       # Discard file changes
git revert HEAD                   # Undo last commit

try {
    // Code that might fail
    const result = 10 / 0;  // Math error!
    console.log(result);
    
    const data = JSON.parse("not valid json");  // Parse error!
    
} catch (error) {
    // Runs if ANY error happens in try
    console.log("Oops! Something went wrong:");
    console.log(error.message);  // "Unexpected token..."
    
    // Show user-friendly message
    showErrorToUser("Please check your input and try again.");
    
} finally {
    // ALWAYS runs, error or not
    console.log("Cleanup: closing connections, hiding loading spinner");
}

// Program continues normally!
console.log("App still running!");

// Custom error throwing
function withdraw(amount) {
    if (amount > balance) {
        throw new Error("Insufficient funds!");
    }
    balance -= amount;
}

// PROMISE - "I promise to give you result later"
function fetchUserData(userId) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (userId) {
                resolve({ id: userId, name: "Alice" });  // Success!
            } else {
                reject("User ID required");  // Error!
            }
        }, 1000);  // Wait 1 second (simulating network)
    });
}

// ASYNC/AWAIT - Cleaner way to handle promises
async function loadUserProfile() {
    try {
        console.log("Loading...");
        
        // Wait for data (but don't block other code!)
        const user = await fetchUserData(123);
        console.log("User loaded:", user);
        
        const posts = await fetchUserPosts(user.id);
        console.log("Posts loaded:", posts);
        
    } catch (error) {
        console.error("Failed to load:", error);
    }
}

// Old way: Callbacks ("callback hell")
getData(function(a) {
    getMoreData(a, function(b) {
        getEvenMoreData(b, function(c) {
            console.log(c);  // Nested callbacks! Hard to read!
        });
    });
});

const fs = require('fs');

// READ a file
fs.readFile('users.txt', 'utf8', (err, data) => {
    if (err) {
        console.error("Error reading file:", err);
        return;
    }
    console.log("File contents:", data);
});

// WRITE to a file
const content = "Hello, this is my file!";
fs.writeFile('output.txt', content, (err) => {
    if (err) throw err;
    console.log("File saved!");
});

// APPEND to a file (add to end)
fs.appendFile('log.txt', "\nNew log entry", (err) => {
    if (err) throw err;
});

// Working with JSON files
const users = [
    { id: 1, name: "Alice" },
    { id: 2, name: "Bob" }
];

// Save JSON
fs.writeFileSync('users.json', JSON.stringify(users, null, 2));

// Load JSON
const loadedUsers = JSON.parse(fs.readFileSync('users.json', 'utf8'));
console.log(loadedUsers);

// Creating regex patterns
const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
const phonePattern = /^\d{3}-\d{3}-\d{4}$/;

// Test if string matches pattern
emailPattern.test("alice@email.com");    // true ✅
emailPattern.test("not-an-email");       // false ❌

phonePattern.test("123-456-7890");      // true ✅
phonePattern.test("1234567890");         // false ❌

// Find and replace
const text = "My email is test@email.com and yours is hello@site.com";
const masked = text.replace(/[^\s@]+@[^\s@]+\.[^\s@]+/g, "***@***.***");
// Result: "My email is ***@***.*** and yours is ***@***.***"

// Extract data
const datePattern = /(\d{4})-(\d{2})-(\d{2})/;
const match = "2024-03-15".match(datePattern);
// match[1] = "2024" (year)
// match[2] = "03" (month)
// match[3] = "15" (day)

// Common regex symbols:
// ^ = start of string
// $ = end of string
// \d = digit (0-9)
// \w = word character (letter, number, _)
// . = any character
// * = 0 or more
// + = 1 or more
// ? = 0 or 1
// {3} = exactly 3
// {2,5} = 2 to 5

class TreeNode {
    constructor(value) {
        this.value = value;
        this.left = null;   // Smaller values go left
        this.right = null;  // Bigger values go right
    }
}

class BinarySearchTree {
    constructor() {
        this.root = null;
    }
    
    insert(value) {
        const newNode = new TreeNode(value);
        
        if (!this.root) {
            this.root = newNode;
            return;
        }
        
        let current = this.root;
        while (true) {
            if (value < current.value) {
                if (!current.left) {
                    current.left = newNode;
                    return;
                }
                current = current.left;
            } else {
                if (!current.right) {
                    current.right = newNode;
                    return;
                }
                current = current.right;
            }
        }
    }
    
    // Search - O(log n) in balanced tree!
    search(value) {
        let current = this.root;
        while (current) {
            if (value === current.value) return true;
            if (value < current.value) current = current.left;
            else current = current.right;
        }
        return false;
    }
}

// Usage
const bst = new BinarySearchTree();
bst.insert(50);
bst.insert(30);
bst.insert(70);
console.log(bst.search(30));  // true
console.log(bst.search(100)); // false

class Graph {
    constructor() {
        this.adjacencyList = {};
    }
    
    addVertex(vertex) {
        if (!this.adjacencyList[vertex]) {
            this.adjacencyList[vertex] = [];
        }
    }
    
    addEdge(v1, v2) {
        this.adjacencyList[v1].push(v2);
        this.adjacencyList[v2].push(v1);  // Undirected
    }
    
    // Breadth First Search - Explore all neighbors first
    BFS(start) {
        const queue = [start];
        const result = [];
        const visited = {};
        visited[start] = true;
        
        while (queue.length) {
            const vertex = queue.shift();
            result.push(vertex);
            
            this.adjacencyList[vertex].forEach(neighbor => {
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    queue.push(neighbor);
                }
            });
        }
        return result;
    }
    
    // Depth First Search - Go deep first, then backtrack
    DFS(start) {
        const result = [];
        const visited = {};
        const adjacencyList = this.adjacencyList;
        
        (function dfs(vertex) {
            if (!vertex) return null;
            visited[vertex] = true;
            result.push(vertex);
            
            adjacencyList[vertex].forEach(neighbor => {
                if (!visited[neighbor]) {
                    dfs(neighbor);
                }
            });
        })(start);
        
        return result;
    }
}

// Usage
const g = new Graph();
g.addVertex("A"); g.addVertex("B"); g.addVertex("C");
g.addEdge("A", "B"); g.addEdge("B", "C");
console.log(g.BFS("A"));  // ["A", "B", "C"]
console.log(g.DFS("A"));  // ["A", "B", "C"]