import { IconName, IconSrc } from '../components/icons';


export const bytesToSize = (bytes: number): string => {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  if (bytes === 0) return '0KB';

  let sizeIndex = Math.floor(Math.log(bytes) / Math.log(1000));

  if (sizeIndex === 0) sizeIndex = 1;

  return `${(bytes / 1000 ** sizeIndex).toFixed(1)} ${sizes[sizeIndex]}`;
};

export const millisecondsToMinutesAndSeconds = (milliseconds: number): string => {
  const seconds = Math.floor(milliseconds / 1000);
  const mm = Math.floor(seconds / 60);
  const ss = Math.round(seconds % 60);
  return `${mm}:${ss < 10 ? '0' : ''}${ss}`;
};

export const millisecondsToMinutes = (milliseconds: number): string => {
  const seconds = Math.floor(milliseconds / 1000);
  const mm = Math.floor(seconds / 60);

  return mm.toString();
};

export const secondsToMinutesAndSeconds = (seconds: number): string => {
  const mm = Math.floor(seconds / 60);
  const ss = Math.round(seconds % 60);
  return `${mm}:${ss < 10 ? '0' : ''}${ss}`;
};

export const getFileTypeIcon = (icons: Record<IconName, IconSrc>, fileType: string): IconSrc => {
  const type = fileType.toLowerCase();
  if (type.startsWith('audio')) {
    return icons.Play;
  }
  if (type.startsWith('video')) {
    return icons.Vlc;
  }
  if (type.startsWith('image')) {
    return icons.Photo;
  }
  return icons.File;
};

export const fulfilledPromiseSettledResult = <T>(prs: PromiseSettledResult<T>[]): T[] =>
  prs.reduce<T[]>((values, pr) => {
    if (pr.status === 'fulfilled') values.push(pr.value);
    return values;
  }, []);

export const promiseFulfilledResult = <T>(
  settledResult: PromiseSettledResult<T>
): T | undefined => {
  if (settledResult.status === 'fulfilled') return settledResult.value;
  return undefined;
};
export const promiseRejectedResult = <T>(settledResult: PromiseSettledResult<T>): any => {
  if (settledResult.status === 'rejected') return settledResult.reason;
  return undefined;
};

export const binarySearch = <T>(items: T[], match: (item: T) => -1 | 0 | 1): T | undefined => {
  const search = (start: number, end: number): T | undefined => {
    if (start > end) return undefined;

    const mid = Math.floor((start + end) / 2);

    const result = match(items[mid]);
    if (result === 0) return items[mid];

    if (result === 1) return search(start, mid - 1);
    return search(mid + 1, end);
  };

  return search(0, items.length - 1);
};

export const randomNumberBetween = (min: number, max: number) =>
  Math.floor(Math.random() * (max - min + 1)) + min;

export const scaleYDimension = (x: number, scaledX: number, y: number): number => {
  const scaleFactor = scaledX / x;
  return scaleFactor * y;
};

/** Fit natural media size into a max box without upscaling. */
export const fitMediaSize = (
  w: number,
  h: number,
  maxW: number,
  maxH: number
): { width: number; height: number } => {
  if (w <= 0 || h <= 0) {
    return { width: maxW, height: Math.round(maxW * 0.75) };
  }
  const scale = Math.min(maxW / w, maxH / h, 1);
  return {
    width: Math.max(1, Math.round(w * scale)),
    height: Math.max(1, Math.round(h * scale)),
  };
};

export const parseGeoUri = (location: string) => {
  const [, data] = location.split(':');
  const [cords] = data.split(';');
  const [latitude, longitude] = cords.split(',');
  return {
    latitude,
    longitude,
  };
};

const START_SLASHES_REG = /^\/+/g;
const END_SLASHES_REG = /\/+$/g;
export const trimLeadingSlash = (str: string): string => str.replace(START_SLASHES_REG, '');
export const trimTrailingSlash = (str: string): string => str.replace(END_SLASHES_REG, '');

export const trimSlash = (str: string): string => trimLeadingSlash(trimTrailingSlash(str));

export const nameInitials = (str: string | undefined | null, len = 1): string => {
  if (!str) return '�';
  return [...str].slice(0, len).join('') || '�';
};

export const randomStr = (len = 12): string => {
  let str = '';
  const minCode = 'A'.charCodeAt(0);
  const maxCode = 'Z'.charCodeAt(0);

  for (let i = 0; i < len; i += 1) {
    const code = Math.floor(Math.random() * (maxCode - minCode + 1) + minCode);
    str += String.fromCharCode(code);
  }
  return str;
};

export const suffixRename = (name: string, validator: (newName: string) => boolean): string => {
  let suffix = 1;
  let newName = name;
  do {
    newName = name + suffix;
    suffix += 1;
  } while (validator(newName));

  return newName;
};

export const replaceSpaceWithDash = (str: string): string => str.replace(/ /g, '-');

export const splitWithSpace = (content: string): string[] => {
  const trimmedContent = content.trim();
  if (trimmedContent === '') return [];
  return trimmedContent.split(' ');
};

/**
 * Strip alpha channel from a color, returning a fully opaque hex color
 * Supports: #RGB, #RGBA, #RRGGBB, #RRGGBBAA, rgb(), rgba()
 */
export const stripAlphaFromColor = (color: string): string => {
  // Handle rgba() format
  const rgbaMatch = color.match(/rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
  if (rgbaMatch) {
    const r = parseInt(rgbaMatch[1], 10).toString(16).padStart(2, '0');
    const g = parseInt(rgbaMatch[2], 10).toString(16).padStart(2, '0');
    const b = parseInt(rgbaMatch[3], 10).toString(16).padStart(2, '0');
    return `#${r}${g}${b}`.toUpperCase();
  }
  
  // Handle hex format
  let hex = color.replace('#', '');
  
  // Convert shorthand #RGB or #RGBA to full form
  if (hex.length === 3 || hex.length === 4) {
    hex = hex.split('').map(c => c + c).join('');
  }
  
  // Take only the first 6 characters (RGB), ignore alpha if present
  return `#${hex.substring(0, 6).toUpperCase()}`;
};

/**
 * Calculate contrasting text color (black or white) for a given background color
 * @param bgColor - Hex color string (e.g., '#RRGGBB' or '#RRGGBBAA')
 * @returns '#000000' for light backgrounds, '#FFFFFF' for dark backgrounds
 */
export const getContrastingTextColor = (bgColor: string): string => {
  // Remove # if present
  const hex = bgColor.replace('#', '');
  
  // Parse RGB values (ignore alpha if present)
  const r = parseInt(hex.substring(0, 2), 16);
  const g = parseInt(hex.substring(2, 4), 16);
  const b = parseInt(hex.substring(4, 6), 16);
  
  // Calculate relative luminance using WCAG formula
  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
  
  // Return black for light backgrounds, white for dark backgrounds
  return luminance > 0.5 ? '#000000' : '#FFFFFF';
};

/**
 * Calculate shadow color for text - white shadow only for very dark text
 * @param textColor - Hex color string (e.g., '#RRGGBB')
 * @returns '#FFFFFF' only for very dark text (close to black), '#000000' otherwise
 */
export const getTextShadowColor = (textColor: string): string => {
  // Remove # if present
  const hex = textColor.replace('#', '');
  
  // Parse RGB values (ignore alpha if present)
  const r = parseInt(hex.substring(0, 2), 16);
  const g = parseInt(hex.substring(2, 4), 16);
  const b = parseInt(hex.substring(4, 6), 16);
  
  // Calculate relative luminance using WCAG formula
  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
  
  // Return white shadow only for very dark text (luminance < 0.2)
  return luminance < 0.2 ? '#FFFFFF' : '#000000';
};