/**
 * 安全的Date工具函数
 * 完全避免使用Date构造函数，防止"Illegal constructor"错误
 */

// Fallback固定时间戳 (2024-10-24 10:00:00 UTC)
const FALLBACK_TIMESTAMP = 1729756800000;

/**
 * 安全地获取当前时间戳
 * 完全不使用Date构造函数
 */
export const safeNow = (): number => {
  try {
    if (typeof window === 'undefined') {
      return FALLBACK_TIMESTAMP;
    }
    // 只使用Date.now()，不使用构造函数
    if (typeof Date !== 'undefined' && Date.now) {
      return Date.now();
    }
    return FALLBACK_TIMESTAMP;
  } catch (e) {
    console.warn('Date.now() error:', e);
    return FALLBACK_TIMESTAMP;
  }
};

/**
 * 将时间戳转换为日期时间各部分
 * 手动实现，不使用Date对象
 * 使用简化的格里高利历算法
 */
const timestampToDateParts = (timestamp: number): {
  year: number;
  month: number;
  day: number;
  hours: number;
  minutes: number;
  seconds: number;
} => {
  // 基本时间单位转换
  const totalSeconds = Math.floor(timestamp / 1000);
  const totalMinutes = Math.floor(totalSeconds / 60);
  const totalHours = Math.floor(totalMinutes / 60);
  const totalDays = Math.floor(totalHours / 24);
  
  // 计算时分秒
  const seconds = totalSeconds % 60;
  const minutes = totalMinutes % 60;
  const hours = totalHours % 24;
  
  // 从1970-01-01开始计算年月日
  // 简化算法：每年365天，每4年一个闰年
  let year = 1970;
  let remainingDays = totalDays;
  
  // 快速计算大致年份
  const approxYears = Math.floor(remainingDays / 365.25);
  year += approxYears;
  remainingDays -= Math.floor(approxYears * 365.25);
  
  // 调整到正确的年份
  while (remainingDays < 0) {
    year--;
    const isLeap = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
    remainingDays += isLeap ? 366 : 365;
  }
  
  while (remainingDays >= 365) {
    const isLeap = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
    const daysInYear = isLeap ? 366 : 365;
    if (remainingDays >= daysInYear) {
      remainingDays -= daysInYear;
      year++;
    } else {
      break;
    }
  }
  
  // 计算月和日（简化版：固定每月天数）
  const monthDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  const isLeapYear = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
  if (isLeapYear) {
    monthDays[1] = 29;
  }
  
  let month = 1;
  let day = remainingDays + 1; // 从1开始
  
  for (let i = 0; i < monthDays.length; i++) {
    if (day <= monthDays[i]) {
      month = i + 1;
      break;
    }
    day -= monthDays[i];
  }
  
  return {
    year,
    month,
    day: Math.max(1, Math.min(31, day)),
    hours,
    minutes,
    seconds,
  };
};

/**
 * 安全地格式化日期时间为 YYYY-MM-DD HH:mm:ss
 * 不使用Date对象，也不使用Intl（避免触发Date构造函数）
 */
export const formatDateTime = (timestamp?: number): string => {
  try {
    if (typeof window === 'undefined') {
      return '2024-10-24 10:00:00';
    }
    
    const ts = timestamp || safeNow();
    
    // 直接使用手动计算，避免任何可能触发Date的API
    const parts = timestampToDateParts(ts);
    const year = String(parts.year).padStart(4, '0');
    const month = String(parts.month).padStart(2, '0');
    const day = String(parts.day).padStart(2, '0');
    const hours = String(parts.hours).padStart(2, '0');
    const minutes = String(parts.minutes).padStart(2, '0');
    const seconds = String(parts.seconds).padStart(2, '0');
    
    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
  } catch (e) {
    console.warn('Date formatting error:', e);
    return '2024-10-24 10:00:00';
  }
};

/**
 * 安全地将时间戳转换为ISO字符串
 * 不使用Date对象，也不使用Intl
 */
export const toISOString = (timestamp?: number): string => {
  try {
    if (typeof window === 'undefined') {
      return '2024-10-24T00:00:00.000Z';
    }
    
    const ts = timestamp || safeNow();
    
    // 使用手动计算
    const parts = timestampToDateParts(ts);
    const year = String(parts.year).padStart(4, '0');
    const month = String(parts.month).padStart(2, '0');
    const day = String(parts.day).padStart(2, '0');
    const hours = String(parts.hours).padStart(2, '0');
    const minutes = String(parts.minutes).padStart(2, '0');
    const seconds = String(parts.seconds).padStart(2, '0');
    
    return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.000Z`;
  } catch (e) {
    console.warn('ISO string conversion error:', e);
    return '2024-10-24T00:00:00.000Z';
  }
};

/**
 * 安全地格式化日期为本地日期字符串
 * 不使用Date对象，也不使用Intl
 */
export const toLocaleDateString = (timestamp: number, locale = 'zh-CN'): string => {
  try {
    if (typeof window === 'undefined') {
      return '2024-10-24';
    }
    
    // 使用手动计算
    const parts = timestampToDateParts(timestamp);
    const year = String(parts.year).padStart(4, '0');
    const month = String(parts.month).padStart(2, '0');
    const day = String(parts.day).padStart(2, '0');
    
    // 根据locale返回不同格式
    if (locale === 'zh-CN') {
      return `${year}-${month}-${day}`;
    }
    
    return `${year}-${month}-${day}`;
  } catch (e) {
    console.warn('Local date string error:', e);
    return '2024-10-24';
  }
};

/**
 * 安全地获取时间戳
 */
export const getTime = (timestamp?: number): number => {
  try {
    if (typeof window === 'undefined') {
      return FALLBACK_TIMESTAMP;
    }
    
    return timestamp || safeNow();
  } catch (e) {
    console.warn('getTime error:', e);
    return FALLBACK_TIMESTAMP;
  }
};

/**
 * 创建一个安全的Date对象（仅在确实需要Date对象时使用）
 * 注意：这个函数可能在某些环境中失败
 */
export const safeDate = (value?: number | string): Date | null => {
  try {
    if (typeof window === 'undefined') {
      return null;
    }
    
    // 尝试创建Date对象，但捕获所有错误
    if (value === undefined) {
      return new Date();
    }
    
    if (typeof value === 'number') {
      return new Date(value);
    }
    
    if (typeof value === 'string') {
      return new Date(value);
    }
    
    return null;
  } catch (e) {
    console.warn('Date creation error:', e);
    return null;
  }
};
