import { MyOperatorUser } from './myoperator.interface';

/**
 * Find the next available extension number
 * @param existingUsers - List of existing MyOperator users
 * @param startFrom - Starting extension number (default: 11)
 * @param maxExtension - Maximum extension number (default: 999)
 * @returns Next available extension number
 */
export function findNextAvailableExtension(
  existingUsers: MyOperatorUser[],
  startFrom: number = 11,
  maxExtension: number = 999,
): number {
  const usedExtensions = new Set(
    existingUsers.map((user) => user.extension).filter(Boolean),
  );

  for (let ext = startFrom; ext <= maxExtension; ext++) {
    if (!usedExtensions.has(ext)) {
      return ext;
    }
  }

  throw new Error(
    `No available extensions between ${startFrom} and ${maxExtension}`,
  );
}

/**
 * Format phone number for MyOperator API
 * Removes country code prefix and non-numeric characters
 * @param phoneNumber - Phone number to format
 * @param countryCode - Country code (e.g., '91' for India)
 * @returns Formatted phone number without country code
 */
export function formatPhoneNumber(
  phoneNumber: string | number,
  countryCode?: string,
): string {
  let phone = String(phoneNumber).replace(/\D/g, ''); // Remove non-numeric

  // Remove country code prefix if present
  if (countryCode && phone.startsWith(countryCode)) {
    phone = phone.substring(countryCode.length);
  }

  // For India, ensure 10-digit number
  if (countryCode === '91' && phone.length > 10) {
    phone = phone.slice(-10);
  }

  return phone;
}

// Re-export masking functions from common utility
export { 
  maskApiToken, 
  maskSensitiveField, 
  maskMyOperatorCredentials 
} from '@/shared/utils/maskingHelper';

/**
 * Validate extension number
 * @param extension - Extension number to validate
 * @returns True if valid, false otherwise
 */
export function isValidExtension(extension: number): boolean {
  return (
    Number.isInteger(extension) &&
    extension >= 11 &&
    extension <= 999
  );
}

/**
 * Parse MyOperator filter string
 * Example: "5 AND 13 OR 8" -> validates format
 * @param filterString - Filter string to validate
 * @returns True if valid format
 */
export function isValidFilterString(filterString: string): boolean {
  if (!filterString) return true;

  // Check for valid format: numbers with AND/OR operators
  const pattern = /^(\d+)(\s+(AND|OR)\s+\d+)*$/i;
  return pattern.test(filterString.trim());
}

/**
 * Build filter string from filter IDs
 * @param filterIds - Array of filter IDs
 * @param operator - Logical operator ('AND' or 'OR')
 * @returns Filter string
 */
export function buildFilterString(
  filterIds: number[],
  operator: 'AND' | 'OR' = 'AND',
): string {
  if (!filterIds || filterIds.length === 0) return '';
  return filterIds.join(` ${operator} `);
}

/**
 * Calculate recording link expiry time (24 hours from now)
 * @returns Expiry date
 */
export function getRecordingLinkExpiry(): Date {
  const expiry = new Date();
  expiry.setHours(expiry.getHours() + 24);
  return expiry;
}

/**
 * Check if recording link is expired
 * @param expiryDate - Expiry date to check
 * @returns True if expired
 */
export function isRecordingLinkExpired(expiryDate: Date): boolean {
  return new Date() > new Date(expiryDate);
}

/**
 * Extract phone number and country code from user phone object
 * @param phone - User phone object { dialCode, number }
 * @returns Object with countryCode and phoneNumber
 */
export function extractPhoneDetails(phone: {
  dialCode: number;
  number: number;
}): { countryCode: string; phoneNumber: string } {
  const countryCode = String(phone.dialCode);
  const phoneNumber = formatPhoneNumber(phone.number, countryCode);

  return { countryCode, phoneNumber };
}

/**
 * Map CRM user to MyOperator user payload
 * @param user - CRM user object
 * @param extension - Extension number to assign
 * @returns MyOperator user creation payload
 */
export function mapUserToMyOperatorPayload(
  user: any,
  extension: number,
): {
  name: string;
  contact_number: string;
  country_code: string;
  extension: number;
  email?: string;
  panel_access?: number;
  receive_calls?: number;
  contact_type?: 'mobile' | 'sip' | 'landline';
} {
  const { countryCode, phoneNumber } = extractPhoneDetails(user.phone);

  return {
    name: `${user.firstName} ${user.lastName}`.trim(),
    contact_number: phoneNumber,
    country_code: countryCode,
    extension,
    email: user.email,
    panel_access: 1,
    receive_calls: 1,
    contact_type: 'mobile',
  };
}