const {
  randomNum,
  basicWordCount,
  btnLink,
  key: AIKey,
  Referer: AIReferer,
  gptName,
  switchBtn,
  mode: initialMode,
  customApi, // 添加这一行
} = GLOBAL_CONFIG.postHeadAiDescription;

async function aiAbstractLocal(num = basicWordCount) {
  // 如果启用了自定义 API，则调用自定义 API
  if (customApi && customApi.enable && customApi.url) {
    await aiAbstractCustom(num);
    return;
  }
  
  // 否则使用文章 Front Matter 中的 ai 字段
  const strArr = postAI.split(",").map(item => item.trim());
  if (strArr.length !== 1) {
    let randomIndex = Math.floor(Math.random() * strArr.length);
    while (randomIndex === lastAiRandomIndex) {
      randomIndex = Math.floor(Math.random() * strArr.length);
    }
    lastAiRandomIndex = randomIndex;
    startAI(strArr[randomIndex]);
  } else {
    startAI(strArr[0]);
  }
  setTimeout(() => {
    aiTitleRefreshIcon.style.opacity = "1";
  }, 600);
}

// 辅助函数：从嵌套对象中获取值，支持数组索引
function getNestedValue(obj, path) {
  if (!path || !obj) return "";
  
  // 处理路径，支持数组索引，如 "choices[0].message.content"
  const parts = path.match(/[^.\[\]]+|\[\d+\]/g) || [];
  let current = obj;
  
  for (const part of parts) {
    if (part.startsWith("[") && part.endsWith("]")) {
      // 数组索引
      const index = parseInt(part.slice(1, -1));
      if (Array.isArray(current) && current[index] !== undefined) {
        current = current[index];
      } else {
        return "";
      }
    } else {
      // 对象属性
      if (current && typeof current === "object" && part in current) {
        current = current[part];
      } else {
        return "";
      }
    }
  }
  
  return typeof current === "string" ? current : "";
}

async function aiAbstractCustom(num) {
  indexI = 0;
  indexJ = 1;
  clearTimeouts();
  animationRunning = false;
  elapsed = 0;
  observer.disconnect();

  num = Math.max(10, Math.min(2000, num));
  const truncateDescription = (title + pageFillDescription).trim().substring(0, num);

  try {
    let animationInterval = null;
    if (animationInterval) clearInterval(animationInterval);
    animationInterval = setInterval(() => {
      const animationText = "生成中" + ".".repeat(indexJ);
      explanation.innerHTML = animationText;
      indexJ = (indexJ % 3) + 1;
    }, 500);

    const method = (customApi.method || "POST").toUpperCase();
    const headers = customApi.headers || { "Content-Type": "application/json" };
    
    let requestOptions = {
      method: method,
      headers: headers,
    };

    if (method === "POST") {
      let requestBody = {};
      
      // OpenAI 格式
      const useOpenAIFormat = customApi.openAIFormat === true || customApi.openAIFormat === "true";
      
      if (useOpenAIFormat) {
        requestBody = {
          model: customApi.model || "gpt-3.5-turbo",
          messages: []
        };
        
        // 添加系统提示词
        if (customApi.systemPrompt) {
          requestBody.messages.push({
            role: "system",
            content: customApi.systemPrompt
          });
        }
        
        // 构建用户消息
        const userPrompt = `请为以下文章生成一段简洁的摘要（约200字）：\n\n标题：${title}\n\n内容：${truncateDescription}`;
        requestBody.messages.push({
          role: "user",
          content: userPrompt
        });
        
        // 可选参数
        if (customApi.temperature !== undefined) {
          requestBody.temperature = customApi.temperature;
        }
        if (customApi.maxTokens !== undefined) {
          requestBody.max_tokens = customApi.maxTokens;
        }
      } else if (customApi.requestBody) {
        // 自定义请求体格式
        if (customApi.requestBody.content) {
          requestBody[customApi.requestBody.content] = truncateDescription;
        }
        if (customApi.requestBody.url) {
          requestBody[customApi.requestBody.url] = location.href;
        }
        if (customApi.requestBody.wordCount) {
          requestBody[customApi.requestBody.wordCount] = num;
        }
      } else {
        // 默认格式
        requestBody.content = truncateDescription;
        requestBody.url = location.href;
        requestBody.wordCount = num;
      }
      
      requestOptions.body = JSON.stringify(requestBody);
    } else {
      // GET 请求：构建 URL 参数
      const params = new URLSearchParams();
      if (customApi.queryParams) {
        if (customApi.queryParams.content) {
          params.append(customApi.queryParams.content, truncateDescription);
        }
        if (customApi.queryParams.url) {
          params.append(customApi.queryParams.url, location.href);
        }
      } else {
        params.append("content", truncateDescription);
        params.append("url", location.href);
      }
      const separator = customApi.url.includes("?") ? "&" : "?";
      customApi.url = customApi.url + separator + params.toString();
    }

    // 发送请求
    const response = await fetch(customApi.url, requestOptions);
    let result;
    
    if (!response.ok) {
      result = {
        error: `请求失败: ${response.status} ${response.statusText}`,
      };
    } else {
      result = await response.json();
    }

    clearInterval(animationInterval);

    // 解析响应数据
    let summaryText = "";
    if (result.error) {
      summaryText = `摘要获取失败: ${result.error}`;
    } else if (customApi.responsePath) {
      summaryText = getNestedValue(result, customApi.responsePath);
      if (!summaryText) {
        summaryText = `摘要获取失败: 响应中未找到路径 ${customApi.responsePath}`;
      }
    } else {
      summaryText = result.summary || result.text || result.content || "";
      if (!summaryText) {
        summaryText = "摘要获取失败: 响应格式不正确";
      }
    }
    
    if (result.error && result.error.message) {
      summaryText = `摘要获取失败: ${result.error.message}`;
    }

    summary = summaryText.trim();
    
    setTimeout(() => {
      aiTitleRefreshIcon.style.opacity = "1";
    }, 300);
    
    if (summary) {
      startAI(summary);
    } else {
      startAI("摘要获取失败，请检查 API 配置和响应格式");
    }
  } catch (error) {
    console.error("自定义 AI API 调用失败:", error);
    explanation.innerHTML = "发生异常: " + error.message;
    startAI("摘要获取失败: " + error.message);
  }
}

async function aiAbstract(num = basicWordCount) {
  if (mode === "tianli") {
    await aiAbstractTianli(num);
  } else {
    await aiAbstractLocal(num); // 改为 await
  }
}