// runnable
const { Worker, isMainThread, parentPort, workerData } = require('node:worker_threads');
const fs = require('node:fs');

function fib(n) { return n < 2 ? n : fib(n - 1) + fib(n - 2); }

if (!isMainThread) {
  parentPort.postMessage(fib(workerData));
} else {
  // Part 1: the order in which the event loop runs things
  console.log('1 sync');
  process.nextTick(() => console.log('2 process.nextTick'));
  Promise.resolve().then(() => console.log('3 promise microtask'));
  fs.readFile(__filename, () => {
    setTimeout(() => console.log('5 setTimeout 0'), 0);
    setImmediate(() => console.log('4 setImmediate'));      // inside an I/O callback, immediate always runs first
  });

  // Part 2: a CPU-bound task blocks the loop, a worker thread does not
  const measureLag = (work) => new Promise((resolve) => {
    let worst = 0;
    let last = Date.now();
    const timer = setInterval(() => {                        // should fire every 10 ms if the loop is healthy
      const now = Date.now();
      worst = Math.max(worst, now - last - 10);
      last = now;
    }, 10);
    setTimeout(async () => {
      await work();
      setTimeout(() => { clearInterval(timer); resolve(worst); }, 30);
    }, 50);
  });

  const onMainThread = async () => { fib(38); };
  const inWorker = () => new Promise((resolve, reject) => {
    const w = new Worker(__filename, { workerData: 38 });
    w.once('message', resolve);
    w.once('error', reject);
  });

  setTimeout(async () => {
    const blocked = await measureLag(onMainThread);
    const offloaded = await measureLag(inWorker);
    console.log('event loop stalled 100 ms or more with CPU work on the main thread:', blocked >= 100);
    console.log('event loop stayed responsive with the work in a worker thread:', offloaded < 100);
  }, 100);
}

// Express: illustrative
import express from 'express';
import { z } from 'zod';

const app = express();
app.use(express.json());                                   // parse JSON bodies
app.use((req, res, next) => {                              // logging middleware
  const start = Date.now();
  res.on('finish', () => console.log(req.method, req.path, res.statusCode, Date.now() - start + 'ms'));
  next();
});

const CreateUser = z.object({ name: z.string().min(1), email: z.string().email() });

app.post('/users', async (req, res) => {
  const parsed = CreateUser.safeParse(req.body);           // validate at the boundary
  if (!parsed.success) return res.status(422).json({ errors: parsed.error.flatten().fieldErrors });
  const user = await userService.create(parsed.data);
  res.status(201).location(`/users/${user.id}`).json(user);
});

app.use((err, req, res, next) => {                         // central error handler
  console.error(err);
  res.status(500).json({ error: 'internal error' });
});

// Fastify: schema drives validation, serialization and docs
app.post('/users', {
  schema: {
    body: { type: 'object', required: ['name'], properties: { name: { type: 'string', minLength: 1 } } },
    response: { 201: { type: 'object', properties: { id: { type: 'integer' }, name: { type: 'string' } } } },
  },
}, async (request, reply) => reply.code(201).send(await users.create(request.body)));

// illustrative Spring Boot code
@RestController
@RequestMapping("/api/users")
class UserController {
    private final UserService users;

    UserController(UserService users) { this.users = users; }        // constructor injection

    @GetMapping("/{id}")
    UserResponse get(@PathVariable long id) { return users.find(id); }

    @PostMapping
    ResponseEntity<UserResponse> create(@Valid @RequestBody CreateUserRequest req) {
        UserResponse created = users.create(req);
        return ResponseEntity.created(URI.create("/api/users/" + created.id())).body(created);
    }
}

record CreateUserRequest(@NotBlank String name, @Email String email) { }
record UserResponse(long id, String name, String email) { }

@Service
class UserService {
    private final UserRepository repo;
    UserService(UserRepository repo) { this.repo = repo; }

    @Transactional
    UserResponse create(CreateUserRequest req) {
        User saved = repo.save(new User(req.name(), req.email()));
        return new UserResponse(saved.getId(), saved.getName(), saved.getEmail());
    }
}

interface UserRepository extends JpaRepository<User, Long> {           // Spring Data generates the implementation
    Optional<User> findByEmail(String email);                           // derived query from the method name
}

@RestControllerAdvice
class ApiErrors {
    @ExceptionHandler(NotFoundException.class)
    ProblemDetail notFound(NotFoundException e) {                        // RFC 9457 support built in
        ProblemDetail p = ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, e.getMessage());
        p.setTitle("Resource not found");
        return p;
    }
}

// runnable
import java.lang.annotation.*;
import java.lang.reflect.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Transactional { }

interface OrderService {
    void placeOrder(String id);
    void placeOrderChecked(String id) throws Exception;
    void audit(String what);
}

class OrderServiceImpl implements OrderService {
    @Transactional
    public void placeOrder(String id) {
        System.out.println("    placing " + id);
        this.audit("placed " + id);                 // self-invocation: calls the target directly, NOT through the proxy
        if (id.startsWith("bad")) throw new IllegalStateException("payment failed");
    }
    @Transactional
    public void placeOrderChecked(String id) throws Exception {
        System.out.println("    placing " + id);
        throw new Exception("checked exception");
    }
    @Transactional
    public void audit(String what) { System.out.println("    audit: " + what); }
}

/** What Spring's @Transactional does: wrap the bean in a proxy that opens and closes a transaction around calls. */
class TxProxy implements InvocationHandler {
    private final Object target;
    private TxProxy(Object target) { this.target = target; }

    static <T> T wrap(T target, Class<T> iface) {
        return iface.cast(Proxy.newProxyInstance(iface.getClassLoader(), new Class<?>[] { iface }, new TxProxy(target)));
    }

    public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
        Method impl = target.getClass().getMethod(m.getName(), m.getParameterTypes());
        if (!impl.isAnnotationPresent(Transactional.class)) return m.invoke(target, args);
        System.out.println("  BEGIN    " + m.getName());
        try {
            Object result = m.invoke(target, args);
            System.out.println("  COMMIT   " + m.getName());
            return result;
        } catch (InvocationTargetException e) {
            Throwable cause = e.getCause();
            if (cause instanceof RuntimeException || cause instanceof Error)
                System.out.println("  ROLLBACK " + m.getName() + " (" + cause.getMessage() + ")");
            else
                System.out.println("  COMMIT   " + m.getName() + " despite the checked exception (" + cause.getMessage() + ")");
            throw cause;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        OrderService svc = TxProxy.wrap(new OrderServiceImpl(), OrderService.class);
        System.out.println("placeOrder(A1): audit() is called inside, but only ONE transaction opens");
        svc.placeOrder("A1");
        System.out.println("placeOrder(bad-2): a RuntimeException rolls back");
        try { svc.placeOrder("bad-2"); } catch (RuntimeException expected) { }
        System.out.println("placeOrderChecked(C3): a checked exception still commits by default");
        try { svc.placeOrderChecked("C3"); } catch (Exception expected) { }
        System.out.println("audit() called directly on the proxy: it does get its own transaction");
        svc.audit("direct call");
    }
}