import jwt from 'jsonwebtoken';
import { User } from '@prisma/client';
import { createUser, createAdminUser, CreateUserInput } from './factories';
import { UserRole } from '../../src/utils/constants';

// Test JWT secrets
const JWT_SECRET = process.env.JWT_SECRET || 'test-jwt-secret-key-for-testing-only';
const JWT_REFRESH_SECRET = process.env.JWT_REFRESH_SECRET || 'test-jwt-refresh-secret-key-for-testing-only';

export interface TokenPayload {
  userId: string;
  email: string;
  role: string;
}

export interface AuthTokens {
  accessToken: string;
  refreshToken: string;
}

export interface AuthenticatedUser {
  user: User;
  tokens: AuthTokens;
}

/**
 * Generate access token for testing
 */
export function generateAccessToken(payload: TokenPayload): string {
  return jwt.sign(payload, JWT_SECRET, { expiresIn: '1h' });
}

/**
 * Generate refresh token for testing
 */
export function generateRefreshToken(payload: TokenPayload): string {
  return jwt.sign(payload, JWT_REFRESH_SECRET, { expiresIn: '7d' });
}

/**
 * Generate both tokens for a user
 */
export function generateTokens(payload: TokenPayload): AuthTokens {
  return {
    accessToken: generateAccessToken(payload),
    refreshToken: generateRefreshToken(payload),
  };
}

/**
 * Get auth token for a specific user ID and role
 */
export function getAuthToken(userId: string, email: string, role: string = UserRole.PLAYER): string {
  return generateAccessToken({ userId, email, role });
}

/**
 * Get full auth headers for HTTP requests
 */
export function getAuthHeaders(userId: string, email: string, role: string = UserRole.PLAYER): { Authorization: string } {
  const token = getAuthToken(userId, email, role);
  return { Authorization: `Bearer ${token}` };
}

/**
 * Create a user with authentication tokens
 */
export async function createAuthenticatedUser(overrides: CreateUserInput = {}): Promise<AuthenticatedUser> {
  const user = await createUser(overrides);
  
  const tokens = generateTokens({
    userId: user.id,
    email: user.email,
    role: user.role,
  });
  
  return { user, tokens };
}

/**
 * Create an admin user with authentication tokens
 */
export async function createAuthenticatedAdmin(overrides: CreateUserInput = {}): Promise<AuthenticatedUser> {
  const user = await createAdminUser(overrides);
  
  const tokens = generateTokens({
    userId: user.id,
    email: user.email,
    role: user.role,
  });
  
  return { user, tokens };
}

/**
 * Create a superadmin user with authentication tokens
 */
export async function createAuthenticatedSuperAdmin(overrides: CreateUserInput = {}): Promise<AuthenticatedUser> {
  const user = await createUser({
    ...overrides,
    role: UserRole.SUPERADMIN,
  });
  
  const tokens = generateTokens({
    userId: user.id,
    email: user.email,
    role: user.role,
  });
  
  return { user, tokens };
}

/**
 * Verify a token (for testing purposes)
 */
export function verifyAccessToken(token: string): TokenPayload {
  return jwt.verify(token, JWT_SECRET) as TokenPayload;
}

/**
 * Verify a refresh token (for testing purposes)
 */
export function verifyRefreshToken(token: string): TokenPayload {
  return jwt.verify(token, JWT_REFRESH_SECRET) as TokenPayload;
}

/**
 * Decode a token without verification (for debugging)
 */
export function decodeToken(token: string): any {
  return jwt.decode(token);
}

/**
 * Create expired token (for testing token expiration)
 */
export function generateExpiredToken(payload: TokenPayload): string {
  return jwt.sign(payload, JWT_SECRET, { expiresIn: '-1s' });
}

/**
 * Create invalid token (signed with wrong secret)
 */
export function generateInvalidToken(payload: TokenPayload): string {
  return jwt.sign(payload, 'wrong-secret-key', { expiresIn: '1h' });
}