/**
 * 标签管理服务
 * 负责标签缓存管理和标签与书签的关联管理
 * 不依赖 Vue 响应式系统，便于后续替换为 API 调用
 */

// 标签到书签 ID 的映射：tag -> Set<linkId>
const tagsMap = new Map()

// 所有标签集合
const allTagsSet = new Set()

// 未分类标签的标识
const UNCATEGORIZED_TAG = '未分类'

/**
 * 规范化标签名称
 */
function normalizeTag(tag) {
  if (!tag || typeof tag !== 'string') return null
  const trimmed = tag.trim()
  return trimmed || null
}

/**
 * 更新标签缓存（单个书签）
 * @param {Object} link - 书签对象
 * @param {string} operation - 操作类型：'add' | 'update' | 'remove'
 * @param {Object} oldLink - 更新操作时的旧书签对象（可选）
 */
function updateFromLink(link, operation, oldLink = null) {
  if (!link || !link.id) return

  const linkId = link.id
  const tags = Array.isArray(link.tags) ? link.tags : []

  if (operation === 'remove') {
    // 删除操作：从所有标签中移除该书签 ID
    tagsMap.forEach((linkIds, tag) => {
      linkIds.delete(linkId)
      // 如果标签下没有书签了，从集合中移除
      if (linkIds.size === 0 && tag !== UNCATEGORIZED_TAG) {
        tagsMap.delete(tag)
        allTagsSet.delete(tag)
      }
    })
    return
  }

  if (operation === 'update' && oldLink) {
    // 更新操作：先移除旧标签，再添加新标签
    const oldTags = Array.isArray(oldLink.tags) ? oldLink.tags : []
    oldTags.forEach((oldTag) => {
      const normalized = normalizeTag(oldTag)
      if (normalized) {
        const linkIds = tagsMap.get(normalized)
        if (linkIds) {
          linkIds.delete(linkId)
          // 如果标签下没有书签了，从集合中移除
          if (linkIds.size === 0 && normalized !== UNCATEGORIZED_TAG) {
            tagsMap.delete(normalized)
            allTagsSet.delete(normalized)
          }
        }
      }
    })
  }

  // 添加新标签
  if (tags.length === 0) {
    // 无标签的书签添加到"未分类"
    if (!tagsMap.has(UNCATEGORIZED_TAG)) {
      tagsMap.set(UNCATEGORIZED_TAG, new Set())
    }
    tagsMap.get(UNCATEGORIZED_TAG).add(linkId)
  } else {
    // 有标签的书签添加到对应标签
    tags.forEach((tag) => {
      const normalized = normalizeTag(tag)
      if (normalized) {
        if (!tagsMap.has(normalized)) {
          tagsMap.set(normalized, new Set())
          allTagsSet.add(normalized)
        }
        tagsMap.get(normalized).add(linkId)
      }
    })
  }
}

/**
 * 从书签列表初始化标签缓存
 * @param {Array} links - 书签数组
 */
function initializeFromLinks(links) {
  // 清空现有缓存
  tagsMap.clear()
  allTagsSet.clear()

  if (!Array.isArray(links) || links.length === 0) {
    return
  }

  // 初始化"未分类"标签
  tagsMap.set(UNCATEGORIZED_TAG, new Set())

  // 遍历所有书签，构建标签映射
  links.forEach((link) => {
    if (!link || !link.id) return

    const tags = Array.isArray(link.tags) ? link.tags : []
    const linkId = link.id

    if (tags.length === 0) {
      // 无标签的书签添加到"未分类"
      tagsMap.get(UNCATEGORIZED_TAG).add(linkId)
    } else {
      // 有标签的书签添加到对应标签
      tags.forEach((tag) => {
        const normalized = normalizeTag(tag)
        if (normalized) {
          if (!tagsMap.has(normalized)) {
            tagsMap.set(normalized, new Set())
            allTagsSet.add(normalized)
          }
          tagsMap.get(normalized).add(linkId)
        }
      })
    }
  })
}

/**
 * 批量更新标签缓存
 * @param {Array} links - 书签数组
 * @param {string} operation - 操作类型：'add' | 'update' | 'remove'
 */
function batchUpdate(links, operation) {
  if (!Array.isArray(links)) return

  links.forEach((link) => {
    updateFromLink(link, operation)
  })
}

/**
 * 获取所有标签（排序后的数组）
 * @param {Array<string>} customOrder - 自定义标签顺序（可选）
 * @returns {Array<string>} 标签数组
 */
function getAllTags(customOrder = null) {
  const tags = Array.from(allTagsSet)
  if (customOrder && Array.isArray(customOrder) && customOrder.length > 0) {
    // 使用自定义顺序排序
    const ordered = []
    const unordered = []
    
    // 先添加有顺序的标签
    customOrder.forEach((tag) => {
      if (tags.includes(tag)) {
        ordered.push(tag)
      }
    })
    
    // 再添加没有顺序的新标签（按字母排序）
    tags.forEach((tag) => {
      if (!customOrder.includes(tag)) {
        unordered.push(tag)
      }
    })
    unordered.sort()
    
    return [...ordered, ...unordered]
  }
  // 默认按字母排序
  return tags.sort()
}

/**
 * 获取标签统计（标签名 -> 书签数量）
 * @returns {Map<string, number>} 标签统计映射
 */
function getTagStats() {
  const stats = new Map()
  tagsMap.forEach((linkIds, tag) => {
    stats.set(tag, linkIds.size)
  })
  return stats
}

/**
 * 检查标签是否在使用中
 * @param {string} tag - 标签名称
 * @returns {boolean} 是否在使用中
 */
function isTagInUse(tag) {
  const normalized = normalizeTag(tag)
  if (!normalized) return false
  const linkIds = tagsMap.get(normalized)
  return linkIds ? linkIds.size > 0 : false
}

/**
 * 获取某个标签下的所有书签 ID
 * @param {string} tag - 标签名称
 * @returns {Set<string>} 书签 ID 集合
 */
function getLinkIdsByTag(tag) {
  const normalized = normalizeTag(tag)
  if (!normalized) return new Set()
  return tagsMap.get(normalized) || new Set()
}

/**
 * 获取按标签分组的书签映射
 * @param {Array} allLinks - 所有书签数组
 * @param {Array<string>} customOrder - 自定义标签顺序（可选）
 * @returns {Map<string, Array>} 标签 -> 书签数组的映射
 */
function getLinksByTag(allLinks, customOrder = null) {
  const result = new Map()
  const linkMap = new Map()
  
  // 构建书签 ID 到书签对象的映射
  if (Array.isArray(allLinks)) {
    allLinks.forEach((link) => {
      if (link && link.id) {
        linkMap.set(link.id, link)
      }
    })
  }

  // 获取标签顺序
  const tagOrder = customOrder && Array.isArray(customOrder) && customOrder.length > 0
    ? customOrder
    : getAllTags()

  // 按顺序遍历标签
  tagOrder.forEach((tag) => {
    const linkIds = tagsMap.get(tag)
    if (linkIds && linkIds.size > 0) {
      const links = []
      linkIds.forEach((linkId) => {
        const link = linkMap.get(linkId)
        if (link) {
          links.push(link)
        }
      })
      if (links.length > 0) {
        result.set(tag, links)
      }
    }
  })

  // 添加未在顺序中的新标签
  tagsMap.forEach((linkIds, tag) => {
    if (!result.has(tag) && linkIds.size > 0) {
      const links = []
      linkIds.forEach((linkId) => {
        const link = linkMap.get(linkId)
        if (link) {
          links.push(link)
        }
      })
      if (links.length > 0) {
        result.set(tag, links)
      }
    }
  })

  return result
}

/**
 * 清空标签缓存
 */
function clear() {
  tagsMap.clear()
  allTagsSet.clear()
  tagsMap.set(UNCATEGORIZED_TAG, new Set())
}

// 导出服务对象
export const tagService = {
  getAllTags,
  getTagStats,
  updateFromLink,
  isTagInUse,
  getLinkIdsByTag,
  batchUpdate,
  initializeFromLinks,
  getLinksByTag,
  clear,
  // 常量
  UNCATEGORIZED_TAG,
}

