/* src/routes/config.ts */

/**
 * @description Defines all available route names as a union of literal types.
 * This acts as the single source of truth for route identifiers.
 */
export type RouteName = 
  | 'home'
  | 'about'
  | 'userProfile'
  | 'productDetail'
  | 'settings';

/**
 * @description Maps each RouteName to its corresponding path pattern.
 * Utilizes template literal types where parameters are involved.
 * Example: ':id' for path parameters.
 */
export const RoutePaths: Record<RouteName, string> = {
  home: '/',
  about: '/about',
  userProfile: '/user/:userId',
  productDetail: '/product/:productId/details',
  settings: '/settings',
};

/**
 * @description Infers the path parameters required for a given RouteName.
 * Extracts literal type parameters from the path string.
 * This uses a conditional type to provide strong typing for route parameters.
 * K extends keyof typeof RoutePaths allows us to iterate over our defined routes.
 * infer Param extracts the string literals after ':'
 */
type PathParams<T extends RouteName> = 
  RoutePaths[T] extends `${infer Start}/:${infer Param}/${infer End}`
    ? { [P in Param]: string } & PathParams<T, `${Start}/${End}`>
    : RoutePaths[T] extends `${infer Start}/:${infer Param}`
      ? { [P in Param]: string }
      : {};

/**
 * @description Defines potential query parameters for specific routes.
 * This allows for optional and strongly-typed query parameters.
 */
interface QueryParams {
  userProfile?: { tab?: 'posts' | 'comments' };
  productDetail?: { variant?: string; referrer?: string };
  // Add other route-specific query params here
}

/**
 * @description Union type that combines path and query parameters for any given route.
 * This provides a comprehensive type for all parameters associated with a route.
 */
export type RouteParams<T extends RouteName> = PathParams<T> & (QueryParams[T] extends Record<string, any> ? QueryParams[T] : {});

// Example usage for debugging/understanding the types:
// type UserProfileRouteParams = RouteParams<'userProfile'>; // Expects { userId: string, tab?: 'posts' | 'comments' }
// type ProductDetailRouteParams = RouteParams<'productDetail'>; // Expects { productId: string, variant?: string, referrer?: string }
// type HomeRouteParams = RouteParams<'home'>; // Expects {}

/* src/routes/helpers.ts */

import { RouteName, RouteParams, RoutePaths } from './config';

/**
 * @description Builds a URL query string from an object of query parameters.
 * Handles optional parameters and encodes values for URL safety.
 */
function buildQueryString(params?: Record<string, string | undefined>): string {
  if (!params) return '';
  const queryString = Object.entries(params)
    .filter(([, value]) => value !== undefined && value !== null)
    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
    .join('&');
  return queryString ? `?${queryString}` : '';
}

/**
 * @description Creates a type-safe link path for a given route name and its parameters.
 * Ensures that all required path parameters are provided and validates query parameters.
 * @template T The RouteName literal type.
 * @param name The name of the route (e.g., 'userProfile').
 * @param params An object containing both path and query parameters, strictly typed by RouteParams<T>.
 * @returns The fully constructed, type-safe URL string.
 */
export function createLink<T extends RouteName>(name: T, params: RouteParams<T>): string {
  let path = RoutePaths[name];

  // Extract path parameters from the provided params object
  const pathParamKeys = (path.match(/:[a-zA-Z0-9_]+/g) || []).map(key => key.substring(1));
  const pathParams: Record<string, string> = {};
  const queryParams: Record<string, string | undefined> = {};

  for (const key in params) {
    if (pathParamKeys.includes(key)) {
      // Ensure path parameters are string for replacement
      pathParams[key] = String(params[key as keyof typeof params]);
    } else {
      // Collect remaining parameters as query parameters
      queryParams[key] = String(params[key as keyof typeof params]);
    }
  }

  // Replace path segments with actual values
  pathParamKeys.forEach(key => {
    if (!pathParams[key]) {
      // This should ideally be caught by TypeScript, but as a runtime fallback:
      console.error(`Missing required path parameter '${key}' for route '${String(name)}'.`);
      throw new Error(`Missing path parameter: ${key}`);
    }
    path = path.replace(`:${key}`, pathParams[key]);
  });

  // Build and append query string
  const queryString = buildQueryString(queryParams);

  return `${path}${queryString}`;
}

// --- Example Usage ---
// import { createLink } from './routes/helpers';
// import { RouteName } from './routes/config';

// const homeLink = createLink('home', {}); // '/'
// console.log('Home Link:', homeLink);

// const userProfileLink = createLink('userProfile', { userId: '123' }); // '/user/123'
// console.log('User Profile Link (basic):', userProfileLink);

// const userProfileWithTabLink = createLink('userProfile', { userId: '456', tab: 'posts' }); // '/user/456?tab=posts'
// console.log('User Profile Link (with tab):', userProfileWithTabLink);

// const productDetailLink = createLink('productDetail', { productId: 'abc-789', variant: 'red', referrer: 'promo' }); // '/product/abc-789/details?variant=red&referrer=promo'
// console.log('Product Detail Link:', productDetailLink);

// // TypeScript Error: Missing 'userId' property
// // const invalidLink = createLink('userProfile', {}); 
// // TypeScript Error: 'unknownParam' not assignable to type 'RouteParams<"home">'
// // const invalidLink2 = createLink('home', { unknownParam: 'value' });

/* src/routes/useRoutes.ts (Example for a React Hook) */

import { useLocation, useParams as useReactRouterParams } from 'react-router-dom';
import { RouteName, RoutePaths, RouteParams } from './config';

// Utility type to extract a subset of an object for specific keys
type PickMatching<T, V> = {
  [K in keyof T as T[K] extends V ? K : never]: T[K];
};

// Utility type to extract string literal keys from a type
type StringLiteralKeys<T> = PickMatching<T, string>;

/**
 * @description Custom hook to provide type-safe access to current route information.
 * It validates the current URL against our defined RoutePaths and extracts parameters safely.
 * This hook assumes integration with a router library that provides 'useLocation' and 'useParams'.
 */
export function useTypeSafeRoute<T extends RouteName>(): {
  name: T | undefined;
  params: RouteParams<T> | undefined;
  // You might add other useful properties like `path`, `isExactMatch` etc.
} {
  const location = useLocation();
  const rawPathParams = useReactRouterParams(); // e.g., { userId: '123' } from react-router-dom

  let matchedRouteName: T | undefined;
  let matchedPath: string | undefined;

  // We need to determine the current route name based on the actual URL path.
  // This simplified example might need more robust path matching for complex cases.
  // In a real application, you'd likely use the router's internal match object or a custom regex matcher.
  for (const name in RoutePaths) {
    const pathPattern = RoutePaths[name as RouteName];
    // Convert path pattern to a regex for matching. Escapes special chars, replaces :params with regex groups.
    const regex = new RegExp(
      '^' + pathPattern.replace(/\/g, '\\/').replace(/:([a-zA-Z0-9_]+)/g, '([^\\/]+)') + '$'
    );
    
    if (regex.test(location.pathname)) {
      matchedRouteName = name as T;
      matchedPath = pathPattern;
      break;
    }
  }

  if (!matchedRouteName || !matchedPath) {
    return { name: undefined, params: undefined };
  }

  // Reconstruct query parameters from location.search
  const queryParams: Record<string, string> = {};
  new URLSearchParams(location.search).forEach((value, key) => {
    queryParams[key] = value;
  });

  // Combine raw path parameters and query parameters
  const combinedParams: RouteParams<T> = {
    ...(rawPathParams as StringLiteralKeys<RouteParams<T>>), // Coerce raw path params
    ...(queryParams as StringLiteralKeys<RouteParams<T>>), // Coerce raw query params
  } as RouteParams<T>; // Final coercion to the strict RouteParams type

  return {
    name: matchedRouteName,
    params: combinedParams,
  };
}

// --- Example Component Usage ---
/*
import React from 'react';
import { BrowserRouter, Routes, Route, Link } from 'react-router-dom';
import { createLink } from './helpers';
import { useTypeSafeRoute } from './useRoutes';
import { RouteName } from './config';

const HomePage = () => {
  const { name, params } = useTypeSafeRoute<'home'>();
  return (
    <div>
      <h1>Home Page</h1>
      <p>Current route: {name}</p>
      <Link to={createLink('userProfile', { userId: '1' })}>Go to User 1</Link>
    </div>
  );
};

const UserProfilePage = () => {
  const { name, params } = useTypeSafeRoute<'userProfile'>();
  const userId = params?.userId;
  const tab = params?.tab;
  return (
    <div>
      <h1>User Profile Page for: {userId}</h1>
      <p>Current route: {name}</p>
      {tab && <p>Active Tab: {tab}</p>}
      <Link to={createLink('productDetail', { productId: 'abc-123' })}>View Product abc-123</Link><br/>
      <Link to={createLink('userProfile', { userId: '1', tab: 'posts' })}>User 1 Posts</Link>
    </div>
  );
};

const ProductDetailPage = () => {
  const { name, params } = useTypeSafeRoute<'productDetail'>();
  const productId = params?.productId;
  const variant = params?.variant;
  return (
    <div>
      <h1>Product Detail for: {productId}</h1>
      <p>Current route: {name}</p>
      {variant && <p>Variant: {variant}</p>}
      <Link to={createLink('home', {})}>Back Home</Link>
    </div>
  );
};

const AppRouter = () => {
  return (
    <BrowserRouter>
      <Routes>
        <Route path={RoutePaths.home} element={<HomePage />} />
        <Route path={RoutePaths.userProfile} element={<UserProfilePage />} />
        <Route path={RoutePaths.productDetail} element={<ProductDetailPage />} />
      </Routes>
    </BrowserRouter>
  );
};

// To run this example, you need react-router-dom installed:
// npm install react-router-dom
// Ensure your main App component renders AppRouter:
// import React from 'react';
// import ReactDOM from 'react-dom/client';
// import AppRouter from './AppRouter'; // assuming the above code is in AppRouter.tsx
// const root = ReactDOM.createRoot(document.getElementById('root') as HTMLElement);
// root.render(<React.StrictMode><AppRouter /></React.StrictMode>);
*/

/* src/routes/config.ts (Advanced Example) */

import { createLink } from './helpers';

// Extend RouteName with a new route and a nested one
export type RouteName = 
  | 'home'
  | 'about'
  | 'userProfile'
  | 'productDetail'
  | 'settings'
  | 'adminDashboard'
  | 'adminUserManagement'; // Nested route example

export const RoutePaths: Record<RouteName, string> = {
  home: '/',
  about: '/about',
  userProfile: '/user/:userId',
  productDetail: '/product/:productId/details',
  settings: '/settings',
  adminDashboard: '/admin',
  adminUserManagement: '/admin/users/:userId?', // Optional parameter for admin routes
};

interface QueryParams {
  userProfile?: { tab?: 'posts' | 'comments' };
  productDetail?: { variant?: string; referrer?: string };
  adminDashboard?: { filter?: 'active' | 'inactive' };
  adminUserManagement?: { status?: 'active' | 'pending' };
}

// (RouteParams type definition remains the same as in config.ts)

/* src/middleware/auth.ts (Example for a simple authentication guard) */

import { RouteName } from '../routes/config';

/**
 * @description Defines authentication requirements for specific routes.
 * This could be extended with roles, permissions, etc.
 */
export const AuthRequiredRoutes: Set<RouteName> = new Set([
  'adminDashboard',
  'adminUserManagement',
  'settings',
  'userProfile', // Example: only logged-in users can view their profile
]);

/**
 * @description Simple authentication check function.
 * In a real app, this would check tokens, user state, etc.
 */
function isAuthenticated(): boolean {
  // Simulate auth state
  return localStorage.getItem('authToken') === 'valid-token';
}

/**
 * @description Guard function for navigating to authenticated routes.
 * Redirects to login if not authenticated.
 * @param routeName The route the user attempts to access.
 * @returns true if allowed, false if redirected.
 */
export function checkAuthGuard(routeName: RouteName): boolean {
  if (AuthRequiredRoutes.has(routeName) && !isAuthenticated()) {
    console.warn(`Access denied for route '${routeName}'. Redirecting to login.`);
    // In a real app, you would redirect to a login page or display an access denied message
    // For demonstration, we'll just log and return false.
    // window.location.href = createLink('login', {}); // Assuming a 'login' route exists
    return false;
  }
  return true;
}

// --- Example Component Using Guard (React) ---
/*
import React, { useEffect } from 'react';
import { useNavigate } from 'react-router-dom';
import { checkAuthGuard } from '../middleware/auth';
import { RouteName } from '../routes/config';
import { useTypeSafeRoute } from '../routes/useRoutes';

interface ProtectedRouteProps {
  children: React.ReactNode;
  routeName: RouteName;
}

const ProtectedRoute: React.FC<ProtectedRouteProps> = ({ children, routeName }) => {
  const navigate = useNavigate();
  const { name } = useTypeSafeRoute<typeof routeName>(); // Narrow the type for the specific route

  useEffect(() => {
    // Only run guard if the current route actually matches the protected routeName
    if (name === routeName && !checkAuthGuard(routeName)) {
      // Redirect to login or home if auth fails
      navigate(createLink('home', {})); // Or createLink('login', { from: name });
    }
  }, [name, routeName, navigate]);

  // Render children only if authenticated or if it's not a protected route (or if auth check is pending)
  return <>{children}</>;
};

// To integrate with AppRouter:
// <Route path={RoutePaths.adminDashboard} element={<ProtectedRoute routeName="adminDashboard"><AdminDashboardPage /></ProtectedRoute>} />
*/