/**
 * 字体加载工具
 * 动态加载字体文件并注入到 CSS 中
 */

import { useFontStore } from '@/store/modules/font'
import { fontList } from '@/api/print/font'

// 获取基础路径
const getBasePath = (): string => {
  const basePath = import.meta.env.VITE_BASE_PATH || ''
  // 确保 basePath 以 / 开头，但不以 / 结尾
  if (basePath && !basePath.startsWith('/')) {
    return `/${basePath}`
  }
  return basePath
}

// 字体接口定义
export interface FontInfo {
  name: string
  fontFamily: string
  fontFile: string
  fontUrl: string
}

// 字体选择数据格式
export interface FontOption {
  title: string
  value: string
}

// 接口返回的字体数据格式
interface ApiFontInfo {
  fileName: string
  fileUrl: string
  fullFileName: string
}

/**
 * 获取字体完整路径
 * @param fontFile 字体文件名
 */
export const getFontFullPath = (fontFile: string): string => {
  // 取当前完整地址，包括端口号
  const origin = window.location.origin
  // 获取基础路径
  const basePath = import.meta.env.VITE_BASE_PATH || ''
  // 对文件名中的空格进行编码，但保留其他字符
  const encodedFontFile = fontFile.replace(/ /g, '%20')
  // 构建路径
  return `${origin}${basePath}font/${encodedFontFile}`
}

/**
 * 获取字体列表
 * 从接口获取字体数据
 */
export const getFontList = async (): Promise<ApiFontInfo[]> => {
  try {
    const response = await fontList()
    const apiFonts = response || []
    
    return apiFonts.map((font: ApiFontInfo) => {
      return {
        name: font.fileName.replace(/ /g, '').split('_')[0],
        fontFamily: font.fileName.replace(/ /g, '').split('_')[0],
        fontFile: font.fullFileName,
        fontUrl: font.fileUrl.replace(/ /g, '%20') // 去除空格
      }
    })
  } catch (error) {
    console.error('获取字体列表失败:', error)
    return []
  }
}

/**
 * 动态加载字体到 CSS
 * @param fontName 字体名称
 * @param fontUrl 字体文件地址
 * @param fontFamily 字体族名称
 */
export const loadFont = (fontName: string, fontUrl: string, fontFamily?: string): Promise<void> => {
  return new Promise((resolve, reject) => {
    // 如果没有提供 fontFamily，使用 fontName 作为 fontFamily
    const family = fontFamily || fontName

    // 根据文件扩展名确定字体格式
    const getFontFormat = (url: string): string => {
      const lowerUrl = url.toLowerCase()
      if (lowerUrl.endsWith('.otf') || lowerUrl.endsWith('.otc')) {
        return 'opentype'
      } else if (lowerUrl.endsWith('.ttf')) {
        return 'truetype'
      } else if (lowerUrl.endsWith('.woff') || lowerUrl.endsWith('.woff2')) {
        return lowerUrl.endsWith('.woff2') ? 'woff2' : 'woff'
      } else if (lowerUrl.endsWith('.eot')) {
        return 'embedded-opentype'
      } else if (lowerUrl.endsWith('.svg') || lowerUrl.endsWith('.svgz')) {
        return 'svg'
      }
      return 'truetype'
    }

    const format = getFontFormat(fontUrl)
    
    console.log(`尝试加载字体:`, { fontName, fontUrl, format, family })
    
    // 创建 @font-face CSS 规则
    const fontFaceRule = `
      @font-face {
        font-family: '${family}';
        src: url('${fontUrl}') format('${format}');
      }
    `
    
    // 将 CSS 规则添加到文档
    const style = document.createElement('style')
    style.textContent = fontFaceRule
    document.head.appendChild(style)
    
    const fontStyle = `
      @font-face {
        font-family: '${family}';
        src: url('${fontUrl}') format('${format}');
      }
    `
    
    const existingStyles = localStorage.getItem('fontStyles') || ''
    localStorage.setItem('fontStyles', existingStyles + fontStyle)
    
    // 等待字体加载
    document.fonts.ready
      .then(() => {
        console.log(`字体 ${fontName} 加载成功`)
        resolve()
      })
      .catch((error) => {
        console.error(`加载字体 ${fontName} 失败:`, error, { fontUrl, format, family })
        reject(error)
      })
  })
}

/**
 * 获取加载完成的字体列表（用于页面选择）
 */
export const getLoadedFonts = (): FontOption[] => {
  return []
}

/**
 * 批量加载所有字体
 */
export const loadAllFonts = async (): Promise<void> => {
  try {
    const fonts = await getFontList()
    // 加载所有字体
    const loadPromises = fonts.map((font) => 
      loadFont(font.fontFamily, font.fontUrl, font.fontFamily)
    )
    // 将加载完成的字体转换为页面选择格式并存入 store
    const fontStore = useFontStore()
    fontStore.setLoadedFonts(fonts.map((font) => ({
      title: font.name,
      value: font.fontFamily
    })))
    await Promise.all(loadPromises)
    console.log('所有字体加载完成')
  } catch (error) {
    console.error('字体加载失败:', error)
  }
}

/**
 * 从 CSS 中移除字体
 * @param fontFamily 字体族名称
 */
export const removeFont = (fontFamily: string): void => {
  // 遍历 document.styleSheets 移除对应的 @font-face
  for (const sheet of document.styleSheets) {
    try {
      const rules = sheet.cssRules || (sheet as any).rules
      if (!rules) continue
      
      for (let i = 0; i < rules.length; i++) {
        const rule = rules[i]
        if (rule instanceof CSSFontFaceRule && rule.style.fontFamily === fontFamily) {
          sheet.deleteRule(i)
          break
        }
      }
    } catch (error) {
      // 跨域样式表会抛出异常，忽略
      console.debug(`无法访问样式表:`, error)
    }
  }
  
  // 从 document.fonts 中移除
  document.fonts.forEach((font) => {
    if (font.family === fontFamily) {
      document.fonts.delete(font)
    }
  })
}
