library-wechat/utils/bookCover.js

import config from '@/utils/config.js'

/**
 * 获取已加载的 bookrecno 缓存
 * @returns {Set} - 已加载的 bookrecno 集合
 */
function getLoadedBookrecnos() {
  const loadedList = wx.getStorageSync('loadedBookrecnos') || [];
  return new Set(loadedList);
}

/**
 * 通过新接口获取单个图书封面（返回 base64）
 * @param {string} isbn - ISBN 号码
 * @returns {Promise<string|null>} - base64 图片字符串或 null
 */
export async function fetchBookCoverBase64(isbn) {
  if (!isbn) {
    return null;
  }
  
  const cleanIsbn = isbn.replace(/-/g, '');
  const url = `${config.baseUrl}/api/fileRelevant/getBookCoverByISBN?isbn=${cleanIsbn}`;
  
  return new Promise((resolve) => {
    uni.request({
      url: url,
      method: 'GET',
      success: (res) => {
        const data = res.data;
        if (data && data !== null && data !== '') {
          // 返回完整的 data URL
          resolve(`${data}`);
        } else {
          resolve(null);
        }
      },
      fail: () => {
        resolve(null);
      }
    });
  });
}

/**
 * 批量获取图书封面（返回 base64）
 * @param {Array} bookList - 图书列表
 * @param {Function} callback - 回调函数 (index, coverUrl)
 * @returns {Promise<void>}
 */
export async function loadBookCoversBase64(bookList, callback) {
  if (!bookList || bookList.length === 0 || typeof callback !== 'function') {
    return;
  }
  
  for (let i = 0; i < bookList.length; i++) {
    const book = bookList[i];
    if (!book.isbn && !book.ISBN) continue;
    
    try {
      const coverUrl = await fetchBookCoverBase64(book.isbn || book.ISBN);
      if (coverUrl) {
        callback(i, coverUrl);
      }
    } catch (error) {
      console.error('获取封面失败:', error);
    }
  }
}

/**
 * 标记 bookrecno 已加载
 * @param {Array} bookrecnoList - 已加载的 bookrecno 列表
 */
function markBookrecnoLoaded(bookrecnoList) {
  const loadedSet = getLoadedBookrecnos();
  bookrecnoList.forEach(bookrecno => loadedSet.add(bookrecno));
  wx.setStorageSync('loadedBookrecnos', Array.from(loadedSet));
}

/**
 * 通过远程接口获取封面（基于 ISBN）
 * @param {Array} isbnList - ISBN 列表
 * @returns {Promise<Object>} - 封面数据映射 { isbn: coverUrl }
 */
export async function fetchCoversByISBN(isbnList) {
  if (!isbnList || isbnList.length === 0) {
    return {};
  }

  // 移除 ISBN 中的连字符
  const cleanIsbns = isbnList.map(isbn => isbn.replace(/-/g, ''));
  const isbns = cleanIsbns.join(',');
  const url = `https://book-resource.dataesb.com/websearch/metares?glc=EGD0755036&cmdACT=getImages&type=0&isbns=${isbns}`;

  return new Promise((resolve) => {
    wx.request({
      url: url,
      method: 'GET',
      success: (res) => {
        const result = {};
        let list = [];
        
        try {
          // 获取响应数据
          let responseData = res.data;
          
          // 如果是字符串，尝试解析为 JSON
          if (typeof responseData === 'string') {
            // 移除可能的 JSONP 包装括号 ({"result":...})
            const trimmed = responseData.trim();
            if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
              responseData = trimmed.slice(1, -1);
            }
            responseData = JSON.parse(responseData);
          }
          
          // 获取 result 数组
          if (responseData && responseData.result && Array.isArray(responseData.result)) {
            list = responseData.result;
          }
        } catch (error) {
          console.error('解析封面数据失败:', error);
          list = [];
        }
        
        list.forEach(item => {
          if (item.isbn && item.coverlink && item.coverlink.indexOf('http') !== -1) {
            // 存储时移除连字符，便于匹配
            result[item.isbn.replace(/-/g, '')] = item.coverlink;
          }
        });
        resolve(result);
      },
      fail: () => {
        resolve({});
      }
    });
  });
}

/**
 * 获取服务器存在的 bookrecno 列表
 * @param {Array} bookrecnoList - bookrecno 列表
 * @returns {Promise<Object>} - 存在的 bookrecno 映射 { bookrecno: coverUrl }
 */
export async function fetchCoversByBookrecno(bookrecnoList) {
  if (!bookrecnoList || bookrecnoList.length === 0) {
    return {};
  }

  const bookrecnos = bookrecnoList.join(',');
  
  return new Promise((resolve) => {
    wx.request({
      url: `http://218.200.95.251:8081/opac/getExistsBookrecnoList/${bookrecnos}`,
      method: 'POST',
      success: (res) => {
        const result = {};
        console.log('bookrecnoList',res)
        const existsList = res.data || [];
        console.log('existsList',existsList)
        existsList.forEach(bookrecno => {
          const timestamp = new Date().getTime();
          result[bookrecno] = `http://218.200.95.251:8081/opac/bscover/${bookrecno}?timestamp=${timestamp}`;
        });
        // 标记已加载
        markBookrecnoLoaded(existsList);
        resolve(result);
      },
      fail: () => {
        resolve({});
      }
    });
  });
}

/**
 * 加载图书封面（核心方法）
 * @param {Array} bookList - 图书数据列表
 * @param {Function} callback - 回调函数，接收 (index, coverUrl) 参数
 * @returns {Promise<void>}
 */
export async function loadBookCovers(bookList, callback) {
  if (!bookList || bookList.length === 0 || typeof callback !== 'function') {
    return;
  }

  try {
    // 分离需要查询的 ISBN 和 bookrecno
    const loadedSet = getLoadedBookrecnos();
    const isbnMap = new Map(); // index -> isbn
    const bookrecnoMap = new Map(); // index -> bookrecno（未加载过的）

    bookList.forEach((book, index) => {
      if (book.isbn) {
        isbnMap.set(index, book.isbn.replace(/-/g, ''));
      }
      if (book.bookrecno && !loadedSet.has(book.bookrecno)) {
        bookrecnoMap.set(index, book.bookrecno);
      }
    });

    // 并行请求 ISBN 和 bookrecno 的封面
    const [isbnCovers, bookrecnoCovers] = await Promise.all([
      fetchCoversByISBN(Array.from(isbnMap.values())),
      fetchCoversByBookrecno(Array.from(bookrecnoMap.values()))
    ]);

    // 更新封面
    bookList.forEach((book, index) => {
      let coverUrl = null;

      // 优先使用 ISBN 获取的封面
      const isbn = book.isbn ? book.isbn.replace(/-/g, '') : null;
      if (isbn && isbnCovers[isbn]) {
        coverUrl = isbnCovers[isbn];
      }
      // 如果 ISBN 没获取到，尝试 bookrecno
      else if (book.bookrecno && bookrecnoCovers[book.bookrecno]) {
        coverUrl = bookrecnoCovers[book.bookrecno];
      }

      if (coverUrl) {
        callback(index, coverUrl);
      }
    });
  } catch (error) {
    console.error('加载图书封面失败:', error);
  }
}

/**
 * 清除封面加载缓存
 */
export function clearCoverCache() {
  wx.removeStorageSync('loadedBookrecnos');
}

export default {
  loadBookCovers,
  clearCoverCache,
  fetchCoversByISBN,
  fetchCoversByBookrecno
};