src/utils/assetRequestHelpers.ts

import { format, formatDistanceToNow, differenceInDays, parseISO } from 'date-fns';
import { AssetRequest, RequestStatus, isValidStatusTransition } from '@/types/asset-request';

// ============================================================================
// DATE FORMATTING HELPERS
// ============================================================================

/**
 * Format a date string for display in the UI
 * @param dateString - ISO 8601 date string
 * @param formatString - Optional format string (default: 'MMM dd, yyyy')
 * @returns Formatted date string
 */
export function formatRequestDate(
  dateString: string | null,
  formatString: string = 'MMM dd, yyyy'
): string {
  if (!dateString) return 'N/A';
  
  try {
    const date = parseISO(dateString);
    return format(date, formatString);
  } catch (error) {
    console.error('Error formatting date:', error);
    return 'Invalid date';
  }
}

/**
 * Format a date string with time for display
 * @param dateString - ISO 8601 date string
 * @returns Formatted date and time string
 */
export function formatRequestDateTime(dateString: string | null): string {
  if (!dateString) return 'N/A';
  
  try {
    const date = parseISO(dateString);
    return format(date, 'MMM dd, yyyy h:mm a');
  } catch (error) {
    console.error('Error formatting date time:', error);
    return 'Invalid date';
  }
}

/**
 * Format a date as relative time (e.g., "2 days ago")
 * @param dateString - ISO 8601 date string
 * @returns Relative time string
 */
export function formatRelativeTime(dateString: string | null): string {
  if (!dateString) return 'N/A';
  
  try {
    const date = parseISO(dateString);
    return formatDistanceToNow(date, { addSuffix: true });
  } catch (error) {
    console.error('Error formatting relative time:', error);
    return 'Invalid date';
  }
}

/**
 * Calculate the age of a request in days
 * @param submittedDate - ISO 8601 date string of submission
 * @returns Number of days since submission
 */
export function calculateRequestAge(submittedDate: string): number {
  try {
    const date = parseISO(submittedDate);
    return differenceInDays(new Date(), date);
  } catch (error) {
    console.error('Error calculating request age:', error);
    return 0;
  }
}

/**
 * Get a human-readable age description for a request
 * @param submittedDate - ISO 8601 date string of submission
 * @returns Age description (e.g., "2 days old", "Just submitted")
 */
export function getRequestAgeDescription(submittedDate: string): string {
  const age = calculateRequestAge(submittedDate);
  
  if (age === 0) return 'Just submitted';
  if (age === 1) return '1 day old';
  if (age < 7) return `${age} days old`;
  if (age < 14) return '1 week old';
  if (age < 30) return `${Math.floor(age / 7)} weeks old`;
  if (age < 60) return '1 month old';
  return `${Math.floor(age / 30)} months old`;
}

// ============================================================================
// STATUS TRANSITION HELPERS
// ============================================================================

/**
 * Validate if a status transition is allowed
 * @param currentStatus - Current request status
 * @param newStatus - Desired new status
 * @returns Validation result with error message if invalid
 */
export function validateStatusTransition(
  currentStatus: RequestStatus,
  newStatus: RequestStatus
): { valid: boolean; error?: string } {
  if (currentStatus === newStatus) {
    return {
      valid: false,
      error: 'Request is already in this status'
    };
  }

  if (!isValidStatusTransition(currentStatus, newStatus)) {
    return {
      valid: false,
      error: `Cannot transition from ${currentStatus} to ${newStatus}`
    };
  }

  return { valid: true };
}

/**
 * Get allowed next statuses for a given current status
 * @param currentStatus - Current request status
 * @returns Array of allowed next statuses
 */
export function getAllowedNextStatuses(currentStatus: RequestStatus): RequestStatus[] {
  const transitions: Record<RequestStatus, RequestStatus[]> = {
    pending: ['approved', 'rejected'],
    approved: ['assigned'],
    rejected: [],
    assigned: []
  };

  return transitions[currentStatus] || [];
}

/**
 * Check if a request can be modified (only pending requests can be modified)
 * @param status - Request status
 * @returns True if request can be modified
 */
export function canModifyRequest(status: RequestStatus): boolean {
  return status === 'pending';
}

/**
 * Check if a request can be cancelled (only pending requests can be cancelled)
 * @param status - Request status
 * @returns True if request can be cancelled
 */
export function canCancelRequest(status: RequestStatus): boolean {
  return status === 'pending';
}

// ============================================================================
// SORTING HELPERS
// ============================================================================

/**
 * Sort requests by submission date (newest first)
 */
export function sortByDateDesc(a: AssetRequest, b: AssetRequest): number {
  return new Date(b.submittedDate).getTime() - new Date(a.submittedDate).getTime();
}

/**
 * Sort requests by submission date (oldest first)
 */
export function sortByDateAsc(a: AssetRequest, b: AssetRequest): number {
  return new Date(a.submittedDate).getTime() - new Date(b.submittedDate).getTime();
}

/**
 * Sort requests by employee name (A-Z)
 */
export function sortByEmployeeName(a: AssetRequest, b: AssetRequest): number {
  return a.employeeName.localeCompare(b.employeeName);
}

/**
 * Sort requests by status (pending first, then approved, rejected, assigned)
 */
export function sortByStatus(a: AssetRequest, b: AssetRequest): number {
  const statusOrder: Record<RequestStatus, number> = {
    pending: 1,
    approved: 2,
    rejected: 3,
    assigned: 4
  };
  
  return statusOrder[a.status] - statusOrder[b.status];
}

/**
 * Sort requests by request ID (newest first)
 */
export function sortByRequestId(a: AssetRequest, b: AssetRequest): number {
  return b.requestID - a.requestID;
}

// ============================================================================
// FILTERING HELPERS
// ============================================================================

/**
 * Filter requests by status
 */
export function filterByStatus(
  requests: AssetRequest[],
  status: RequestStatus
): AssetRequest[] {
  return requests.filter(req => req.status === status);
}

/**
 * Filter requests by employee ID
 */
export function filterByEmployeeId(
  requests: AssetRequest[],
  employeeId: number
): AssetRequest[] {
  return requests.filter(req => req.employeeID === employeeId);
}

/**
 * Filter requests by date range
 */
export function filterByDateRange(
  requests: AssetRequest[],
  startDate: string,
  endDate: string
): AssetRequest[] {
  const start = parseISO(startDate);
  const end = parseISO(endDate);
  
  return requests.filter(req => {
    const reqDate = parseISO(req.submittedDate);
    return reqDate >= start && reqDate <= end;
  });
}

/**
 * Filter requests by search term (searches in justification, asset types, and comments)
 */
export function filterBySearchTerm(
  requests: AssetRequest[],
  searchTerm: string
): AssetRequest[] {
  if (!searchTerm.trim()) return requests;
  
  const term = searchTerm.toLowerCase();
  
  return requests.filter(req =>
    req.requestID.toString().includes(term) ||
    req.employeeName.toLowerCase().includes(term) ||
    req.justification.toLowerCase().includes(term) ||
    req.requestedAssets.some(asset =>
      asset.assetType.toLowerCase().includes(term) ||
      asset.specifications.toLowerCase().includes(term)
    ) ||
    (req.adminComments && req.adminComments.toLowerCase().includes(term))
  );
}

/**
 * Filter requests by asset type
 */
export function filterByAssetType(
  requests: AssetRequest[],
  assetType: string
): AssetRequest[] {
  return requests.filter(req =>
    req.requestedAssets.some(asset => asset.assetType === assetType)
  );
}

/**
 * Filter old pending requests (older than specified days)
 */
export function filterOldPendingRequests(
  requests: AssetRequest[],
  daysThreshold: number = 30
): AssetRequest[] {
  return requests.filter(req => {
    if (req.status !== 'pending') return false;
    const age = calculateRequestAge(req.submittedDate);
    return age >= daysThreshold;
  });
}

// ============================================================================
// AGGREGATION HELPERS
// ============================================================================

/**
 * Get request counts by status
 */
export function getRequestCountsByStatus(
  requests: AssetRequest[]
): Record<RequestStatus, number> {
  return {
    pending: requests.filter(r => r.status === 'pending').length,
    approved: requests.filter(r => r.status === 'approved').length,
    rejected: requests.filter(r => r.status === 'rejected').length,
    assigned: requests.filter(r => r.status === 'assigned').length
  };
}

/**
 * Get total requested quantity for a specific asset type
 */
export function getTotalRequestedQuantity(
  requests: AssetRequest[],
  assetType: string,
  statusFilter?: RequestStatus[]
): number {
  let filteredRequests = requests;
  
  if (statusFilter && statusFilter.length > 0) {
    filteredRequests = requests.filter(req => statusFilter.includes(req.status));
  }
  
  return filteredRequests.reduce((total, req) => {
    const assetItem = req.requestedAssets.find(asset => asset.assetType === assetType);
    return total + (assetItem?.quantity || 0);
  }, 0);
}

/**
 * Get unique asset types from requests
 */
export function getUniqueAssetTypes(requests: AssetRequest[]): string[] {
  const assetTypes = new Set<string>();
  
  requests.forEach(req => {
    req.requestedAssets.forEach(asset => {
      assetTypes.add(asset.assetType);
    });
  });
  
  return Array.from(assetTypes).sort();
}

/**
 * Calculate average processing time for completed requests (approved or rejected)
 * @param requests - Array of asset requests
 * @returns Average processing time in days, or null if no completed requests
 */
export function calculateAverageProcessingTime(requests: AssetRequest[]): number | null {
  const completedRequests = requests.filter(
    req => (req.status === 'approved' || req.status === 'rejected') && req.reviewedDate
  );
  
  if (completedRequests.length === 0) return null;
  
  const totalDays = completedRequests.reduce((sum, req) => {
    const submitted = parseISO(req.submittedDate);
    const reviewed = parseISO(req.reviewedDate!);
    return sum + differenceInDays(reviewed, submitted);
  }, 0);
  
  return Math.round(totalDays / completedRequests.length);
}

// ============================================================================
// VALIDATION HELPERS
// ============================================================================

/**
 * Check if a request is stale (pending for too long)
 * @param request - Asset request
 * @param daysThreshold - Number of days to consider stale (default: 30)
 * @returns True if request is stale
 */
export function isStaleRequest(request: AssetRequest, daysThreshold: number = 30): boolean {
  if (request.status !== 'pending') return false;
  return calculateRequestAge(request.submittedDate) >= daysThreshold;
}

/**
 * Check if a request requires urgent attention (pending for more than 7 days)
 * @param request - Asset request
 * @returns True if request requires urgent attention
 */
export function requiresUrgentAttention(request: AssetRequest): boolean {
  if (request.status !== 'pending') return false;
  return calculateRequestAge(request.submittedDate) >= 7;
}

/**
 * Get priority level for a request based on age
 * @param request - Asset request
 * @returns Priority level: 'low', 'medium', 'high', or 'urgent'
 */
export function getRequestPriority(
  request: AssetRequest
): 'low' | 'medium' | 'high' | 'urgent' {
  if (request.status !== 'pending') return 'low';
  
  const age = calculateRequestAge(request.submittedDate);
  
  if (age >= 14) return 'urgent';
  if (age >= 7) return 'high';
  if (age >= 3) return 'medium';
  return 'low';
}