background.js

// 任务状态枚举
const TASK_STATUS = {
  IDLE: 'idle',
  RUNNING: 'running',
  PAUSED: 'paused',
  COMPLETED: 'completed',
  FAILED: 'failed'
};

// 辅助函数：获取 URL 的 origin
function getOrigin(url) {
  if (!url) return '';
  try {
    const urlObj = new URL(url);
    return urlObj.origin;
  } catch (e) {
    return '';
  }
}

// 初始化：监听安装
chrome.runtime.onInstalled.addListener(() => {
  chrome.storage.local.set({
    currentTask: null, // 当前任务对象 { id, steps, currentIndex, status, targetUrl }
    taskLog: [],
    recordedActions: [], // 录制的动作列表（兼容旧版本）
    isRecording: false, // 录制状态
    flows: [], // 多流程列表 [{id, name, steps, schedule, createdAt, lastRunAt}]
    currentFlowId: null, // 当前选中的流程ID
    lastRecordedTab: null // 最后记录的 Tab 信息 {tabId, url, title}
  });
  
  // 自动打开侧边栏
  chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true });
});

// 监听来自 Popup 或 Content 的消息
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  handle_message(request, sender, sendResponse);
  return true; // 保持异步响应
});

async function handle_message(request, sender, sendResponse) {
  const { type, payload } = request;

  if (type === 'START_TASK') {
    await startTask(payload.steps);
    sendResponse({ success: true });
  }

  else if (type === 'STEP_COMPLETED') {
    // 某一步执行成功，推进队列
    await nextStep();
    sendResponse({ success: true });
  }

  else if (type === 'STEP_FAILED') {
    // 执行失败，记录日志并暂停任务
    const stepIndex = payload?.stepIndex || 0;
    const error = payload?.error || 'Unknown error';
    
    // 暂停任务
    const storage = await chrome.storage.local.get(['currentTask']);
    let task = storage.currentTask;
    if (task) {
      task.status = TASK_STATUS.PAUSED;
      task.endTime = Date.now();
      await chrome.storage.local.set({ currentTask: task });
      console.log('[Background] 任务因步骤失败而暂停');
    }
    
    await logError(stepIndex + 1, error); // 步骤编号从1开始
    sendResponse({ success: true });
  }

  else if (type === 'KEEP_ALIVE') {
    // 心跳包，防止 SW 休眠
    sendResponse({ status: 'alive' });
  }

  else if (type === 'GET_TASK_STATUS') {
    const data = await chrome.storage.local.get(['currentTask']);
    sendResponse(data.currentTask || { status: TASK_STATUS.IDLE });
  }

  else if (type === 'SAVE_ACTION') {
    // 保存录制的动作
    const action = payload || request.action;
    if (!action) {
      console.error('[Background] SAVE_ACTION 消息格式错误:', request);
      sendResponse({ success: false, error: 'Missing action data' });
      return;
    }
    
    // 获取当前 Tab 信息
    let tabInfo = null;
    if (sender.tab) {
      tabInfo = {
        tabId: sender.tab.id,
        url: sender.tab.url,
        title: sender.tab.title
      };
    }
    
    const storage = await chrome.storage.local.get(['recordedActions', 'currentFlowId', 'flows', 'lastRecordedTab']);
    let actions = storage.recordedActions || [];
    const lastRecordedTab = storage.lastRecordedTab || null;
    
    // 智能检测网页切换
    let needNavigateAction = false;
    if (tabInfo) {
      // 检查是否切换了网页（通过 tabId 和 URL 的 origin 判断）
      if (!lastRecordedTab || 
          lastRecordedTab.tabId !== tabInfo.tabId || 
          getOrigin(lastRecordedTab.url) !== getOrigin(tabInfo.url)) {
        needNavigateAction = true;
        console.log('[Background] 检测到网页切换，需要添加导航指令');
        console.log('[Background] 上一个 Tab:', lastRecordedTab);
        console.log('[Background] 当前 Tab:', tabInfo);
      }
    }
    
    // 如果需要，先添加导航指令
    if (needNavigateAction && tabInfo) {
      const navigateAction = {
        type: 'navigate',
        url: tabInfo.url,
        title: tabInfo.title,
        tabId: tabInfo.tabId,
        timestamp: Date.now()
      };
      
      // 检查最后一个动作是否已经是相同的导航指令
      const lastAction = actions[actions.length - 1];
      const isLastNavigate = lastAction && 
                            lastAction.type === 'navigate' && 
                            getOrigin(lastAction.url) === getOrigin(navigateAction.url);
      
      if (!isLastNavigate) {
        actions.push(navigateAction);
        console.log('[Background] 添加导航指令:', navigateAction);
        await logMessage(`打开网页: ${tabInfo.title || tabInfo.url}`);
      }
      
      // 更新最后记录的 Tab 信息
      await chrome.storage.local.set({ lastRecordedTab: tabInfo });
    }
    
    // 检查是否是重复动作
    const lastAction = actions[actions.length - 1];
    if (lastAction) {
      const isDuplicate = (
        lastAction.type === action.type &&
        lastAction.selector === action.selector &&
        lastAction.value === action.value &&
        Math.abs(lastAction.timestamp - action.timestamp) < 100
      );
      
      if (isDuplicate) {
        console.log('[Background] 检测到重复动作，忽略:', action);
        sendResponse({ success: true });
        return;
      }
    }
    
    // 为动作添加 Tab 信息（但不包含完整 URL，只保留 origin）
    if (tabInfo) {
      action.tabId = tabInfo.tabId;
      action.pageOrigin = getOrigin(tabInfo.url);
      action.pageTitle = tabInfo.title;
    }
    
    actions.push(action);
    await chrome.storage.local.set({ recordedActions: actions });
    
    // 如果有当前流程ID，也更新到对应流程的steps中
    if (storage.currentFlowId && storage.flows) {
      const flows = storage.flows;
      const flowIndex = flows.findIndex(f => f.id === storage.currentFlowId);
      if (flowIndex !== -1) {
        flows[flowIndex].steps = [...actions];
        flows[flowIndex].updatedAt = Date.now();
        await chrome.storage.local.set({ flows: flows });
      }
    }
    
    // 添加到任务日志
    let actionDesc = '';
    if (action.type === 'click') {
      actionDesc = `点击: ${action.tagName} (${action.selector})`;
    } else if (action.type === 'type') {
      actionDesc = `输入: ${action.value} (${action.selector})`;
    } else if (action.type === 'wait') {
      actionDesc = `等待: ${action.duration}ms`;
    }
    await logMessage(`录制动作: ${actionDesc}`);
    
    console.log('[Background] 保存动作成功:', action);
    sendResponse({ success: true });
  }

  else if (type === 'GET_ACTIONS') {
    const storage = await chrome.storage.local.get(['recordedActions']);
    sendResponse(storage.recordedActions || []);
  }

  else if (type === 'GET_FLOWS') {
    const storage = await chrome.storage.local.get(['flows']);
    sendResponse(storage.flows || []);
  }

  else if (type === 'CREATE_FLOW') {
    const flowName = payload?.name || '新流程';
    const newFlow = {
      id: Date.now().toString(),
      name: flowName,
      steps: [],
      schedule: null,
      createdAt: Date.now(),
      updatedAt: Date.now(),
      lastRunAt: null
    };
    
    const storage = await chrome.storage.local.get(['flows']);
    const flows = storage.flows || [];
    flows.push(newFlow);
    await chrome.storage.local.set({ flows: flows, currentFlowId: newFlow.id, recordedActions: [] });
    
    await logMessage(`创建流程: ${flowName}`);
    sendResponse({ success: true, flow: newFlow });
  }

  else if (type === 'SELECT_FLOW') {
    const flowId = payload?.flowId;
    if (!flowId) {
      sendResponse({ success: false, error: 'Missing flowId' });
      return;
    }
    
    const storage = await chrome.storage.local.get(['flows']);
    const flows = storage.flows || [];
    const flow = flows.find(f => f.id === flowId);
    
    if (flow) {
      await chrome.storage.local.set({ currentFlowId: flowId, recordedActions: flow.steps || [] });
      sendResponse({ success: true, flow: flow });
    } else {
      sendResponse({ success: false, error: 'Flow not found' });
    }
  }

  else if (type === 'UPDATE_FLOW') {
    const { flowId, updates } = payload;
    if (!flowId) {
      sendResponse({ success: false, error: 'Missing flowId' });
      return;
    }
    
    const storage = await chrome.storage.local.get(['flows']);
    const flows = storage.flows || [];
    const flowIndex = flows.findIndex(f => f.id === flowId);
    
    if (flowIndex !== -1) {
      flows[flowIndex] = { ...flows[flowIndex], ...updates, updatedAt: Date.now() };
      await chrome.storage.local.set({ flows: flows });
      
      const currentStorage = await chrome.storage.local.get(['currentFlowId']);
      if (currentStorage.currentFlowId === flowId) {
        await chrome.storage.local.set({ recordedActions: flows[flowIndex].steps || [] });
      }
      
      sendResponse({ success: true, flow: flows[flowIndex] });
    } else {
      sendResponse({ success: false, error: 'Flow not found' });
    }
  }

  else if (type === 'DELETE_FLOW') {
    const flowId = payload?.flowId;
    if (!flowId) {
      sendResponse({ success: false, error: 'Missing flowId' });
      return;
    }
    
    const storage = await chrome.storage.local.get(['flows', 'currentFlowId']);
    let flows = storage.flows || [];
    const flowIndex = flows.findIndex(f => f.id === flowId);
    
    if (flowIndex !== -1) {
      const deletedFlow = flows[flowIndex];
      flows.splice(flowIndex, 1);
      
      let newCurrentFlowId = storage.currentFlowId;
      if (newCurrentFlowId === flowId) {
        newCurrentFlowId = flows.length > 0 ? flows[0].id : null;
        await chrome.storage.local.set({ recordedActions: newCurrentFlowId ? flows[0].steps : [] });
      }
      
      await chrome.storage.local.set({ flows: flows, currentFlowId: newCurrentFlowId });
      await logMessage(`删除流程: ${deletedFlow.name}`);
      sendResponse({ success: true });
    } else {
      sendResponse({ success: false, error: 'Flow not found' });
    }
  }

  else if (type === 'CLEAR_ACTIONS') {
    await chrome.storage.local.set({ recordedActions: [] });
    sendResponse({ success: true });
  }

  else if (type === 'TOGGLE_RECORDING') {
    const storage = await chrome.storage.local.get(['isRecording']);
    const currentStatus = storage.isRecording || false;
    const newStatus = !currentStatus;
    await chrome.storage.local.set({ isRecording: newStatus });
    
    console.log('[Background] 录制状态已切换:', currentStatus, '->', newStatus);
    await logMessage(`录制状态: ${newStatus ? '开始' : '停止'}`);
    
    if (newStatus) {
      // 开始录制时，清空上次记录的 Tab 信息
      await chrome.storage.local.set({ lastRecordedTab: null });
      
      const tabs = await chrome.tabs.query({});
      for (const tab of tabs) {
        try {
          await chrome.tabs.sendMessage(tab.id, { type: 'TOGGLE_RECORDING', status: true });
          console.log(`[Background] 已通知 Tab ${tab.id} 开始录制`);
        } catch (e) {
          console.warn(`[Background] 无法通知 Tab ${tab.id} 开始录制:`, e);
        }
      }
    } else {
      const tabs = await chrome.tabs.query({});
      for (const tab of tabs) {
        try {
          await chrome.tabs.sendMessage(tab.id, { type: 'TOGGLE_RECORDING', status: false });
          console.log(`[Background] 已通知 Tab ${tab.id} 停止录制`);
        } catch (e) {
          console.warn(`[Background] 无法通知 Tab ${tab.id} 停止录制:`, e);
        }
      }
      
      // 停止录制时，清空上次记录的 Tab 信息
      await chrome.storage.local.set({ lastRecordedTab: null });
    }
    
    sendResponse({ status: newStatus });
  }

  else if (type === 'STOP_TASK') {
    await stopTask();
    sendResponse({ success: true });
  }
}

// 启动任务
async function startTask(steps) {
  const taskId = Date.now().toString();
  const task = {
    id: taskId,
    steps: steps,
    currentIndex: 0,
    status: TASK_STATUS.RUNNING,
    startTime: Date.now(),
    lastActiveTabId: null
  };

  await chrome.storage.local.set({ currentTask: task, taskLog: [`任务 ${taskId} 启动，共 ${steps.length} 步`] });
  console.log(`[Scheduler] 任务 ${taskId} 开始`);

  executeCurrentStep(task);
}

// 执行当前步骤
async function executeCurrentStep(taskData) {
  const storage = await chrome.storage.local.get(['currentTask']);
  let task = storage.currentTask;

  if (!task || task.status !== TASK_STATUS.RUNNING) return;
  if (task.currentIndex >= task.steps.length) {
    await finishTask(task, true);
    return;
  }

  const step = task.steps[task.currentIndex];
  
  try {
    if (step.waitBefore && step.waitBefore > 0) {
      console.log(`[Scheduler] 执行前等待 ${step.waitBefore}ms`);
      await logMessage(`步骤 ${task.currentIndex + 1} 执行前等待 ${step.waitBefore}ms`);
      await new Promise(resolve => setTimeout(resolve, step.waitBefore));
    }
    
    if (step.type === 'navigate') {
      console.log('[Scheduler] 执行 navigate 操作:', step.url);
      
      // 查找是否已有相同 origin 的 Tab
      const tabs = await chrome.tabs.query({});
      const targetOrigin = getOrigin(step.url);
      let existingTab = tabs.find(tab => tab.url && getOrigin(tab.url) === targetOrigin);
      
      if (existingTab) {
        // 如果已有相同 origin 的 Tab，激活并导航
        await chrome.tabs.update(existingTab.id, { active: true, url: step.url });
        await logMessage(`激活并导航到: ${step.title || step.url}`);
        
        // 等待页面加载完成
        await new Promise(resolve => {
          chrome.tabs.onUpdated.addListener(function listener(tabId, changeInfo) {
            if (tabId === existingTab.id && changeInfo.status === 'complete') {
              chrome.tabs.onUpdated.removeListener(listener);
              resolve();
            }
          });
        });
        
        task.lastActiveTabId = existingTab.id;
      } else {
        // 否则创建新 Tab
        const newTab = await chrome.tabs.create({ url: step.url, active: true });
        await logMessage(`打开新网页: ${step.title || step.url}`);
        
        // 等待页面加载完成
        await new Promise(resolve => {
          chrome.tabs.onUpdated.addListener(function listener(tabId, changeInfo) {
            if (tabId === newTab.id && changeInfo.status === 'complete') {
              chrome.tabs.onUpdated.removeListener(listener);
              resolve();
            }
          });
        });
        
        task.lastActiveTabId = newTab.id;
      }
      
      await chrome.storage.local.set({ currentTask: task });
      await nextStep();
      return;
    }
    
    // 对于 click 和 type 操作，使用当前活动的 Tab
    let tab;
    if (task.lastActiveTabId) {
      try {
        tab = await chrome.tabs.get(task.lastActiveTabId);
        console.log('[Scheduler] 使用上次活动的 Tab:', tab.id);
      } catch (e) {
        console.warn('[Scheduler] 上次活动的 Tab 不存在，使用当前活动 Tab');
        const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
        tab = tabs[0];
      }
    } else {
      const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
      tab = tabs[0];
    }
    
    if (!tab) {
      console.error('[Scheduler] 无法找到活动的 Tab');
      await logError(task.currentIndex + 1, '无法找到活动的 Tab');
      
      task.status = TASK_STATUS.PAUSED;
      task.endTime = Date.now();
      await chrome.storage.local.set({ currentTask: task });
      return;
    }

    task.lastActiveTabId = tab.id;
    await chrome.storage.local.set({ currentTask: task });

    console.log('[Scheduler] 发送执行指令到 Tab:', tab.id, '步骤:', step);
    
    chrome.tabs.sendMessage(tab.id, {
      type: 'EXECUTE_STEP',
      step: step,
      taskIndex: task.currentIndex
    }, (response) => {
      if (chrome.runtime.lastError) {
        console.error('[Scheduler] 发送失败:', chrome.runtime.lastError);
        console.warn('[Scheduler] 等待页面加载后重试...');
        
        chrome.tabs.onUpdated.addListener(function listener(tabId, changeInfo) {
          if (tabId === tab.id && changeInfo.status === 'complete') {
            chrome.tabs.onUpdated.removeListener(listener);
            console.log('[Scheduler] Tab 加载完成，重试发送指令');
            setTimeout(() => executeCurrentStep(task), 500);
          }
        });
        
        setTimeout(() => executeCurrentStep(task), 3000);
      } else {
        console.log('[Scheduler] 发送成功，等待步骤完成');
      }
    });

  } catch (error) {
    console.error('[Scheduler] 执行出错:', error);
    await logError(task.currentIndex + 1, error.message);
    
    task.status = TASK_STATUS.PAUSED;
    task.endTime = Date.now();
    await chrome.storage.local.set({ currentTask: task });
    console.log('[Background] 任务因执行出错而暂停');
  }
}

async function nextStep() {
  const storage = await chrome.storage.local.get(['currentTask']);
  let task = storage.currentTask;
  if (!task) return;

  task.currentIndex++;
  await chrome.storage.local.set({ currentTask: task });

  executeCurrentStep(task);
}



async function finishTask(task, success) {
  task.status = success ? TASK_STATUS.COMPLETED : TASK_STATUS.FAILED;
  task.endTime = Date.now();
  await chrome.storage.local.set({ currentTask: task });
  await logMessage(`任务结束：${success ? '成功' : '失败'}`);
  console.log(`[Scheduler] 任务 ${task.id} 结束`);
}

async function logMessage(msg) {
  const storage = await chrome.storage.local.get(['taskLog']);
  const logs = storage.taskLog || [];
  logs.push(`[${new Date().toLocaleTimeString()}] ${msg}`);
  if (logs.length > 50) logs.shift();
  await chrome.storage.local.set({ taskLog: logs });
}

async function logError(index, error) {
  await logMessage(`步骤 ${index} 出错：${error}，任务已暂停`);
}

async function stopTask() {
  const storage = await chrome.storage.local.get(['currentTask']);
  const task = storage.currentTask;
  
  if (!task) return;
  
  task.status = TASK_STATUS.PAUSED;
  task.endTime = Date.now();
  await chrome.storage.local.set({ currentTask: task });
  
  await logMessage(`任务已停止，当前进度：${task.currentIndex}/${task.steps.length}`);
  console.log(`[Scheduler] 任务 ${task.id} 已停止`);
}