/*
  This package.json illustrates a basic monorepo setup for a tRPC project.
  It segregates server, client, and a 'shared' package for common types and logic.
  This structure ensures type inference works seamlessly across boundaries.
*/
{
  "name": "trpc-monorepo",
  "version": "1.0.0",
  "private": true,
  "workspaces": [
    "apps/*",
    "packages/*"
  ],
  "scripts": {
    "dev": "turbo run dev",
    "build": "turbo run build",
    "clean": "turbo run clean",
    "lint": "turbo run lint"
  },
  "devDependencies": {
    "turbo": "^2.0.8",
    "typescript": "^5.5.4"
  }
}

/*
  This code sets up a minimal tRPC server. It defines a single router with a 'greeting' procedure.
  Zod is used to define input schemas, ensuring strong type validation for incoming data.
  tRPC infers the types of inputs and outputs directly from these definitions.
*/

import { initTRPC } from '@trpc/server';
import { createHTTPServer } from '@trpc/server/adapters/standalone';
import { z } from 'zod'; // Zod for schema validation

// 1. Initialize tRPC with a context type (empty for now, will be expanded later)
const t = initTRPC.create();

// 2. Define the app router
const appRouter = t.router({
  // A query procedure to get a greeting message
  greeting: t.procedure
    .input(z.object({
      name: z.string().min(1) // Defines that 'name' is a required string
    }))
    .query(({ input }) => {
      return { text: `Hello, ${input.name}!` };
    }),

  // An example of a mutation procedure (e.g., for creating or updating data)
  // createUser: t.procedure
  //   .input(z.object({
  //     email: z.string().email(),
  //     password: z.string().min(8)
  //   }))
  //   .mutation(({ input }) => {
  //     // Logic to create user in DB
  //     return { id: Math.random().toString(36).substr(2, 9), email: input.email };
  //   }),
});

// 3. Export the app router's type definition
// This is crucial for the client to infer types without code generation.
export type AppRouter = typeof appRouter;

// 4. Create and start the HTTP server
const server = createHTTPServer({
  router: appRouter,
  // Optional: Add createContext function here if context is needed (e.g., auth, DB access)
});

const PORT = 2025;
server.listen(PORT);
console.log(`tRPC server listening on http://localhost:${PORT}`);

/*
  To run this server:
  1. npm install @trpc/server @trpc/server-adapters zod typescript ts-node
  2. Create tsconfig.json:
     {
       "compilerOptions": {
         "target": "es2020",
         "module": "commonjs",
         "esModuleInterop": true,
         "forceConsistentCasingInFileNames": true,
         "strict": true,
         "skipLibCheck": true
       }
     }
  3. npx ts-node server.ts
*/

/*
  This React component demonstrates how to consume the tRPC API on the client-side.
  It uses @trpc/react-query for seamless integration with React Query's caching and data management.
  Crucially, the 'createTRPCReact' helper infers all available procedures and their types directly from the shared 'AppRouter' type.
*/

import React from 'react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { httpBatchLink } from '@trpc/client';
import { createTRPCReact } from '@trpc/react-query';

// Import the AppRouter type from the server or a shared package
// In a monorepo, this would be: import type { AppRouter } from 'shared/trpc-types';
// For a simple example, we might define a dummy type or rely on direct import if server and client are in same project root
// For this example, let's assume 'shared' package exports AppRouter.
// In a real monorepo, ensure the 'shared' package is built and linked correctly.
// For simplicity in this standalone example, we'll define a placeholder type, but in practice, you'd import it.

// --- IMPORTANT: In a real monorepo, this type would be imported from a shared package. ---
// Example of how AppRouter type might look if manually defined (for illustration only, avoid in real project):
// type AppRouter = {
//   greeting: {
//     input: { name: string; };
//     output: { text: string; };
//   };
// };
// --- End of IMPORTANT ---

// Placeholder type to make the example runnable without a full monorepo setup for 'shared'
// In a real project, replace this with: import type { AppRouter } from '../path/to/server/index';
interface AppRouter {
  greeting: {
    input: { name: string };
    output: { text: string };
  };
}

// Create a tRPC client instance
const trpc = createTRPCReact<AppRouter>();

// Initialize QueryClient for React Query
const queryClient = new QueryClient();

// Main App component
function App() {
  // Configure tRPC client with a link to the server
  const trpcClient = trpc.createClient({
    links: [
      httpBatchLink({
        url: 'http://localhost:2025',
      }),
    ],
  });

  return (
    <trpc.Provider client={trpcClient} queryClient={queryClient}>
      <QueryClientProvider client={queryClient}>
        <GreetingComponent />
      </QueryClientProvider>
    </trpc.Provider>
  );
}

// Component that fetches and displays the greeting
function GreetingComponent() {
  // Use tRPC's strongly typed `useQuery` hook
  // The 'greeting' procedure and its 'input' are automatically inferred
  const { data, isLoading, error } = trpc.greeting.useQuery({ name: 'Developer' });

  if (isLoading) return <p>Loading greeting...</p>;
  if (error) return <p>Error: {error.message}</p>;

  // 'data' is strongly typed as { text: string } because of server inference
  return <p>{data?.text}</p>;
}

export default App;

/*
  To run this client:
  1. Ensure the tRPC server from the previous step is running.
  2. npm create vite@latest client -- --template react-ts
  3. cd client
  4. npm install @tanstack/react-query @trpc/client @trpc/react-query
  5. Replace src/App.tsx with the code above.
  6. npm run dev
*/

/*
  This code enhances the tRPC server with a context function and middleware.
  Context allows injecting objects (e.g., database clients, authenticated user) into procedures.
  Middleware provides a way to run logic before a procedure executes, useful for authentication or logging.
  Both context and middleware are fully type-safe, ensuring robust application logic.
*/

import { initTRPC, TRPCError } from '@trpc/server';
import { createHTTPServer } from '@trpc/server/adapters/standalone';
import { z } from 'zod';

// Define the context type. This will be available in all procedures and middlewares.
interface Context {
  userId: string | null;
  db: { // Simulate a database client
    getUserById: (id: string) => { id: string, name: string } | undefined;
  };
}

// A dummy database for demonstration
const dummyDb = {
  users: [
    { id: 'user-1', name: 'Alice' },
    { id: 'user-2', name: 'Bob' }
  ],
  getUserById: function(id: string) {
    return this.users.find(u => u.id === id);
  }
};

// 1. Initialize tRPC with the context type
const t = initTRPC.context<Context>().create();

// 2. Define a reusable middleware for authentication
// This middleware checks if a user is authenticated (userId is not null)
const isAuthenticated = t.middleware(({ ctx, next }) => {
  if (!ctx.userId) {
    throw new TRPCError({
      code: 'UNAUTHORIZED',
      message: 'You must be logged in to access this resource',
    });
  }
  // If authenticated, proceed to the next middleware or the procedure
  return next({
    ctx: {
      // Pass through the authenticated userId
      userId: ctx.userId,
    },
  });
});

// Create a reusable procedure that requires authentication
const protectedProcedure = t.procedure.use(isAuthenticated);

// 3. Define the app router with enhanced procedures
const appRouter = t.router({
  greeting: t.procedure
    .input(z.object({
      name: z.string().min(1)
    }))
    .query(({ input, ctx }) => {
      // We can access context here
      console.log('Context userId in greeting:', ctx.userId);
      return { text: `Hello, ${input.name}! From user: ${ctx.userId || 'Guest'}` };
    }),

  // A protected procedure that can only be called by authenticated users
  whoami: protectedProcedure
    .query(({ ctx }) => {
      const user = ctx.db.getUserById(ctx.userId!); // userId is guaranteed to be non-null here
      return { id: ctx.userId, name: user?.name || 'Unknown' };
    }),
});

export type AppRouter = typeof appRouter;

// 4. Create the context function
// This function runs on every incoming request and creates the 'ctx' object.
const createContext = () => {
  // In a real application, you would parse headers for auth tokens,
  // connect to a database, etc., to populate the context.
  const userId = Math.random() > 0.5 ? 'user-1' : null; // Simulate random authentication
  console.log('Simulated request for userId:', userId);

  return {
    userId,
    db: dummyDb,
  };
};

// 5. Create and start the HTTP server with the context function
const server = createHTTPServer({
  router: appRouter,
  createContext,
});

const PORT = 2025;
server.listen(PORT);
console.log(`tRPC server with context and middleware listening on http://localhost:${PORT}`);

/*
  To run this server:
  1. npm install @trpc/server @trpc/server-adapters zod typescript ts-node
  2. Ensure tsconfig.json is configured correctly.
  3. npx ts-node server.ts
  Test client with: curl http://localhost:2025/greeting?input={"name":"World"}
  Test whoami (might fail or succeed based on random auth): curl http://localhost:2025/whoami
*/

/*
  This code demonstrates a modular approach to organizing tRPC routers.
  Breaking down your API into logical sub-routers enhances maintainability and scalability.
  This is particularly beneficial in larger applications or monorepos.
*/

import { initTRPC } from '@trpc/server';
import { z } from 'zod';
import type { Context } from './context'; // Assume context is defined in a separate file

const t = initTRPC.context<Context>().create();

// --- Feature-specific Routers ---

// 1. User Router
const userRouter = t.router({
  getById: t.procedure
    .input(z.object({ id: z.string() }))
    .query(({ input, ctx }) => {
      // Access ctx.db for database operations
      console.log('Fetching user by ID:', input.id, 'for user:', ctx.userId);
      const user = ctx.db.getUserById(input.id);
      if (!user) {
        throw new t.TRPCError({ code: 'NOT_FOUND', message: 'User not found' });
      }
      return user;
    }),
  updateName: t.procedure
    .input(z.object({
      id: z.string(),
      newName: z.string().min(1)
    }))
    // Assume this is a protected procedure, perhaps using a `protectedProcedure` helper
    .mutation(({ input, ctx }) => {
      console.log('Updating user name for:', input.id, 'by user:', ctx.userId);
      // Logic to update user in DB
      return { success: true, userId: input.id, newName: input.newName };
    }),
});

// 2. Post Router
const postRouter = t.router({
  getAll: t.procedure
    .query(({ ctx }) => {
      console.log('Fetching all posts for user:', ctx.userId);
      // Logic to fetch posts from DB
      return [{ id: 'post-1', title: 'First Post', authorId: 'user-1' }];
    }),
  createPost: t.procedure
    .input(z.object({
      title: z.string().min(5),
      content: z.string().min(10)
    }))
    // Assume this is a protected procedure
    .mutation(({ input, ctx }) => {
      console.log('Creating post for user:', ctx.userId, 'Title:', input.title);
      // Logic to create post in DB
      return { id: Math.random().toString(36).substr(2, 9), ...input, authorId: ctx.userId };
    }),
});

// --- Root App Router ---

// Combine all feature-specific routers into a single root router
export const appRouter = t.router({
  user: userRouter, // Mount the user router under 'user.' namespace
  post: postRouter, // Mount the post router under 'post.' namespace
  // Other global procedures can go here if needed
  healthcheck: t.procedure.query(() => ({ status: 'ok' }))
});

export type AppRouter = typeof appRouter;

/*
  Client-side usage would then be:
  trpc.user.getById.useQuery({ id: 'user-1' })
  trpc.post.createPost.useMutation({ title: 'New Post', content: 'Lorem ipsum...' })

  To run this example (assumes a context.ts and server.ts exists that uses this modular router):
  1. Create separate files for context.ts, userRouter.ts, postRouter.ts, and then an index.ts that combines them.
  2. Ensure your main tRPC server (e.g., server.ts) imports and uses the `appRouter`.
*/