// hello.ts - No configuration needed!
interface User {
  id: number;
  name: string;
  email: string;
}

async function fetchUser(id: number): Promise<User> {
  const response = await fetch(`https://jsonplaceholder.typicode.com/users/${id}`);
  return await response.json();
}

const user = await fetchUser(1);
console.log(`Hello, ${user.name}!`);

// server.ts
import { Application, Router, Context } from "https://deno.land/x/oak@v12.6.1/mod.ts";
import { oakCors } from "https://deno.land/x/cors@v1.2.2/mod.ts";

interface Todo {
  id: string;
  title: string;
  completed: boolean;
  createdAt: Date;
}

// In-memory store (use a database in production)
const todos = new Map<string, Todo>();

const router = new Router();

// GET /todos
router.get("/todos", (ctx: Context) => {
  ctx.response.body = {
    success: true,
    data: Array.from(todos.values()),
  };
});

// POST /todos
router.post("/todos", async (ctx: Context) => {
  const body = await ctx.request.body().value;
  
  const todo: Todo = {
    id: crypto.randomUUID(),
    title: body.title,
    completed: false,
    createdAt: new Date(),
  };
  
  todos.set(todo.id, todo);
  
  ctx.response.status = 201;
  ctx.response.body = { success: true, data: todo };
});

// PATCH /todos/:id
router.patch("/todos/:id", async (ctx: Context) => {
  const { id } = ctx.params;
  const todo = todos.get(id!);
  
  if (!todo) {
    ctx.response.status = 404;
    ctx.response.body = { success: false, error: "Todo not found" };
    return;
  }
  
  const updates = await ctx.request.body().value;
  const updated = { ...todo, ...updates };
  todos.set(id!, updated);
  
  ctx.response.body = { success: true, data: updated };
});

// DELETE /todos/:id
router.delete("/todos/:id", (ctx: Context) => {
  const { id } = ctx.params;
  const deleted = todos.delete(id!);
  
  ctx.response.body = { 
    success: deleted,
    message: deleted ? "Deleted" : "Not found"
  };
});

const app = new Application();

// Middleware
app.use(oakCors());
app.use(async (ctx, next) => {
  const start = Date.now();
  await next();
  const ms = Date.now() - start;
  console.log(`${ctx.request.method} ${ctx.request.url} - ${ms}ms`);
});

app.use(router.routes());
app.use(router.allowedMethods());

console.log("Server running on http://localhost:8000");
await app.listen({ port: 8000 });

// npm-example.ts
import express from "npm:express@4";
import { z } from "npm:zod";

// Zod for validation
const UserSchema = z.object({
  name: z.string().min(2),
  email: z.string().email(),
  age: z.number().int().positive().optional(),
});

const app = express();
app.use(express.json());

app.post("/users", (req, res) => {
  const result = UserSchema.safeParse(req.body);
  
  if (!result.success) {
    return res.status(400).json({
      error: "Validation failed",
      issues: result.error.issues,
    });
  }
  
  res.status(201).json({
    message: "User created",
    user: result.data,
  });
});

app.listen(3000, () => {
  console.log("Express on Deno running on port 3000");
});

// Using the standard library
import { serve } from "https://deno.land/std@0.208.0/http/server.ts";
import { join } from "https://deno.land/std@0.208.0/path/mod.ts";
import { parse } from "https://deno.land/std@0.208.0/flags/mod.ts";
import { format } from "https://deno.land/std@0.208.0/datetime/mod.ts";
import { crypto } from "https://deno.land/std@0.208.0/crypto/mod.ts";

// CLI argument parsing
const args = parse(Deno.args, {
  string: ["port", "host"],
  boolean: ["help"],
  default: { port: "8000", host: "localhost" },
});

if (args.help) {
  console.log(`
Usage: deno run --allow-net server.ts [options]

Options:
  --port    Port to listen on (default: 8000)
  --host    Host to bind to (default: localhost)
  --help    Show this help message
  `);
  Deno.exit(0);
}

// Generate a secure token
async function generateToken(): Promise<string> {
  const buffer = new Uint8Array(32);
  crypto.getRandomValues(buffer);
  return Array.from(buffer)
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

// Date formatting
const startTime = format(new Date(), "yyyy-MM-dd HH:mm:ss");
console.log(`Server started at ${startTime}`);

// user_service_test.ts
import { assertEquals, assertThrows } from "https://deno.land/std@0.208.0/assert/mod.ts";
import { describe, it, beforeEach } from "https://deno.land/std@0.208.0/testing/bdd.ts";
import { stub, spy } from "https://deno.land/std@0.208.0/testing/mock.ts";

interface User {
  id: string;
  name: string;
  email: string;
}

class UserService {
  private users = new Map<string, User>();
  
  create(name: string, email: string): User {
    if (!email.includes("@")) {
      throw new Error("Invalid email");
    }
    
    const user: User = {
      id: crypto.randomUUID(),
      name,
      email,
    };
    
    this.users.set(user.id, user);
    return user;
  }
  
  get(id: string): User | undefined {
    return this.users.get(id);
  }
  
  list(): User[] {
    return Array.from(this.users.values());
  }
}

describe("UserService", () => {
  let service: UserService;
  
  beforeEach(() => {
    service = new UserService();
  });
  
  describe("create", () => {
    it("should create a user with valid data", () => {
      const user = service.create("John Doe", "john@example.com");
      
      assertEquals(user.name, "John Doe");
      assertEquals(user.email, "john@example.com");
      assertEquals(typeof user.id, "string");
    });
    
    it("should throw on invalid email", () => {
      assertThrows(
        () => service.create("John", "invalid-email"),
        Error,
        "Invalid email"
      );
    });
  });
  
  describe("list", () => {
    it("should return all users", () => {
      service.create("User 1", "user1@example.com");
      service.create("User 2", "user2@example.com");
      
      const users = service.list();
      assertEquals(users.length, 2);
    });
  });
});

// Async tests
Deno.test("fetchUser should return user data", async () => {
  const mockFetch = stub(
    globalThis,
    "fetch",
    () => Promise.resolve(new Response(
      JSON.stringify({ id: 1, name: "Test User" }),
      { status: 200 }
    ))
  );
  
  try {
    const response = await fetch("https://api.example.com/users/1");
    const user = await response.json();
    
    assertEquals(user.name, "Test User");
  } finally {
    mockFetch.restore();
  }
});

// routes/index.tsx
import { Handlers, PageProps } from "$fresh/server.ts";

interface Data {
  count: number;
}

export const handler: Handlers<Data> = {
  async GET(req, ctx) {
    const count = await getVisitorCount();
    return ctx.render({ count });
  },
};

export default function Home({ data }: PageProps<Data>) {
  return (
    <div class="p-4 mx-auto max-w-screen-md">
      <h1 class="text-4xl font-bold">Welcome to Fresh!</h1>
      <p class="my-4">
        You are visitor #{data.count}
      </p>
      <Counter start={3} />
    </div>
  );
}

// islands/Counter.tsx - Interactive island
import { useState } from "preact/hooks";

interface Props {
  start: number;
}

export default function Counter({ start }: Props) {
  const [count, setCount] = useState(start);
  
  return (
    <div class="flex gap-2 items-center">
      <button
        class="px-4 py-2 bg-blue-500 text-white rounded"
        onClick={() => setCount(count - 1)}
      >
        -
      </button>
      <span class="text-2xl">{count}</span>
      <button
        class="px-4 py-2 bg-blue-500 text-white rounded"
        onClick={() => setCount(count + 1)}
      >
        +
      </button>
    </div>
  );
}

// deploy.ts - Works on Deno Deploy edge network
Deno.serve(async (req) => {
  const url = new URL(req.url);
  
  if (url.pathname === "/") {
    return new Response("Hello from the edge!", {
      headers: { "content-type": "text/plain" },
    });
  }
  
  if (url.pathname === "/api/time") {
    return Response.json({
      timestamp: Date.now(),
      iso: new Date().toISOString(),
      region: Deno.env.get("DENO_REGION") ?? "unknown",
    });
  }
  
  return new Response("Not Found", { status: 404 });
});