handle function application

async function handle(message: ExtensionMessage): Promise<unknown> {
  switch (message.type) {
    case "GET_RULES":
      return getRules();

    case "SAVE_RULE": {
      const rule = parseRulePayload(message.payload);
      if (!rule) return { error: "Invalid payload for SAVE_RULE" };

      // Upsert by selector + URL pattern: if a rule already exists for the same
      // fieldSelector and matching URL pattern, re-use its ID so it gets updated
      // instead of creating a duplicate with a different ID.
      const allRules = await getRules();
      const existing = allRules.find(
        (r) =>
          r.fieldSelector === rule.fieldSelector &&
          r.urlPattern === rule.urlPattern,
      );
      const ruleToSave = existing
        ? { ...rule, id: existing.id, createdAt: existing.createdAt }
        : rule;

      await saveRule(ruleToSave);
      const signals = buildSignalsFromRule(ruleToSave);
      if (signals) {
        await storeLearnedEntry(
          signals,
          ruleToSave.fieldType,
          undefined,
          "rule",
        );
        await addDatasetEntry({
          signals,
          type: ruleToSave.fieldType,
          source: "manual",
          difficulty: "easy",
        });
      }
      void broadcastToAllTabs({ type: "INVALIDATE_CLASSIFIER" });
      return { success: true };
    }

    case "DELETE_RULE": {
      const ruleId = parseStringPayload(message.payload);
      if (!ruleId) return { error: "Invalid payload for DELETE_RULE" };
      await deleteRule(ruleId);
      return { success: true };
    }

    case "SAVE_FIELD_OVERRIDE": {
      const p = parseSaveFieldOverridePayload(message.payload);
      if (!p) return { error: "Invalid payload for SAVE_FIELD_OVERRIDE" };

      // Derive a hostname-level URL pattern so the rule applies to all pages
      // on the same domain (e.g. *://example.com/*)
      let urlPattern = "*";
      try {
        const parsed = new URL(p.url);
        urlPattern = `${parsed.protocol}//${parsed.hostname}/*`;
      } catch {
        // Fallback: use the raw URL as pattern
        urlPattern = p.url;
      }

      // Find existing rule for same URL pattern + fieldSelector
      const allRules = await getRules();
      const existing = allRules.find(
        (r) =>
          r.fieldSelector === p.fieldSelector &&
          matchUrlPattern(p.url, r.urlPattern),
      );

      const now = Date.now();
      const rule: FieldRule = {
        id: existing?.id ?? crypto.randomUUID(),
        urlPattern,
        fieldSelector: p.fieldSelector,
        fieldName: p.fieldName,
        fieldType: p.fieldType,
        generator: p.generator,
        fixedValue: p.fixedValue,
        aiPrompt: p.aiPrompt,
        generatorParams: p.generatorParams,
        selectOptionIndex: p.selectOptionIndex,
        priority: 100,
        createdAt: existing?.createdAt ?? now,
        updatedAt: now,
      };

      await saveRule(rule);
      const signals = buildSignalsFromRule(rule);
      if (signals) {
        await storeLearnedEntry(signals, rule.fieldType, undefined, "rule");
        await addDatasetEntry({
          signals,
          type: rule.fieldType,
          source: "manual",
          difficulty: "easy",
        });
      }
      void broadcastToAllTabs({ type: "INVALIDATE_CLASSIFIER" });
      return { success: true, rule };
    }

    case "DELETE_FIELD_OVERRIDE": {
      const p = parseDeleteFieldOverridePayload(message.payload);
      if (!p) return { error: "Invalid payload for DELETE_FIELD_OVERRIDE" };

      const allRules = await getRules();
      const match = allRules.find(
        (r) =>
          r.fieldSelector === p.fieldSelector &&
          matchUrlPattern(p.url, r.urlPattern),
      );
      if (!match) return { success: true }; // no rule to delete

      await deleteRule(match.id);
      return { success: true };
    }

    default:
      return { error: `Unhandled type in rulesHandler: ${message.type}` };
  }
}