merge_css.js

const fs = require("fs");
const path = require("path");
const css = require("css");

let selectorCounter = 1;

// Utility to generate stable selector IDs
function generateSelectorId() {
  return `sel-${String(selectorCounter++).padStart(3, "0")}`;
}

// Add ID comments in --view mode
function addSelectorAnchors(ast) {
  ast.stylesheet.rules.forEach((rule) => {
    if (rule.type === "rule") {
      const id = generateSelectorId();
      rule.selectors = rule.selectors.map((sel) => `${sel} /* ID:${id} */`);
    } else if (rule.rules) {
      addSelectorAnchors({ stylesheet: { rules: rule.rules } });
    }
  });
}

// Strip ID comments before saving
function stripSelectorAnchors(ast) {
  ast.stylesheet.rules.forEach((rule) => {
    if (rule.type === "rule") {
      rule.selectors = rule.selectors.map((sel) =>
        sel.replace(/\s*\/\*\s*ID:[^)]+\*\//, "").trim()
      );
    } else if (rule.rules) {
      stripSelectorAnchors({ stylesheet: { rules: rule.rules } });
    }
  });
}

function mergeCSS(originalContent, aiContent) {
  const originalAST = css.parse(originalContent || "", { source: "original" });
  const aiAST = css.parse(aiContent || "", { source: "ai" });

  // Consolidate the original CSS to handle pre-existing duplicates.
  originalAST.stylesheet.rules = consolidateRules(originalAST.stylesheet.rules);

  // Merge the AI edits.
  originalAST.stylesheet.rules = mergeRules(
    originalAST.stylesheet.rules,
    aiAST.stylesheet.rules
  );

  // Strip ID anchors before writing back
  stripSelectorAnchors(originalAST);

  return css.stringify(originalAST, { compress: false });
}

async function mergeAllFiles(files, aiEdits, projectRoot) {
  files.forEach((file) => {
    if (file.path.endsWith(".css") && aiEdits[file.path]) {
      try {
        const absolutePath = path.resolve(projectRoot, file.path);
        const originalContent = fs.existsSync(absolutePath)
          ? fs.readFileSync(absolutePath, "utf-8")
          : "";
        const merged = mergeCSS(originalContent, aiEdits[file.path]);
        fs.writeFileSync(absolutePath, merged, "utf-8");
        console.log(`[LOG] Merged AI edits into ${file.path} -> ${absolutePath}`);
      } catch (err) {
        console.error(`[ERROR] Failed to merge ${file.path}:`, err.message);
        process.exit(1);
      }
    }
  });
}

function mergeDeclarations(origDecls, aiDecls) {
  let merged = [...origDecls];
  let deleteRule = false;

  aiDecls.forEach((aiDecl) => {
    if (aiDecl.type !== "declaration") return;

    // Delete entire rule
    if (aiDecl.property === "DELETE_THIS" && aiDecl.value === "DELETE_THIS") {
      deleteRule = true;
      return;
    }

    // Delete specific property
    if (aiDecl.value === "DELETE_THIS") {
      const exists = merged.some((d) => d.property === aiDecl.property);
      if (!exists) {
        throw new Error(
          `Tried to delete property "${aiDecl.property}" but it does not exist in this selector.`
        );
      }
      merged = merged.filter((d) => d.property !== aiDecl.property);
      return;
    }

    // Add or override property
    const idx = merged.findIndex((d) => d.property === aiDecl.property);
    if (idx >= 0) {
      merged[idx].value = aiDecl.value;
    } else {
      merged.push(aiDecl);
    }
  });

  if (deleteRule) return null;

  // Deduplicate properties while keeping last occurrence
  const seen = new Map();
  merged.forEach((decl) => {
    if (decl.type !== "declaration") return;
    seen.set(decl.property, decl);
  });
  return Array.from(seen.values());
}

// Merge rules recursively (handles @media/@supports)
function mergeRules(origRules, aiRules) {
  const merged = [...origRules];

  aiRules.forEach((aiRule) => {
    if (aiRule.type === "rule") {
      aiRule.selectors.forEach((rawSelector) => {
        let selector = rawSelector.trim();
        let isNewSelector = false;

        // Explicit new selector prefix
        if (selector.startsWith("NEW_SELECTOR:")) {
          isNewSelector = true;
          selector = selector.replace(/^NEW_SELECTOR:\s*/, "");
        }

        // Match including ID anchors
        const existingMatches = merged.filter(
          (r) =>
            r.type === "rule" &&
            r.selectors.some((sel) => sel.replace(/\s*\/\*\s*ID:[^)]+\*\//, "").trim() === selector)
        );

        if (existingMatches.length > 1) {
          throw new Error(
            `Ambiguity: Selector "${selector}" found multiple times. Use the ID comment from --view output to disambiguate.`
          );
        }

        const existing = existingMatches[0];

        if (existing) {
          const newDecls = mergeDeclarations(existing.declarations, aiRule.declarations);
          if (newDecls === null) {
            // Drop this rule completely
            const idx = merged.indexOf(existing);
            if (idx >= 0) merged.splice(idx, 1);
          } else {
            existing.declarations = newDecls;
          }
        } else {
          if (!isNewSelector) {
            throw new Error(
              `Selector "${selector}" not found in file. To add new selectors, use the "NEW_SELECTOR:" prefix.`
            );
          }

          // Valid explicit new selector
          const newDecls = mergeDeclarations([], aiRule.declarations);
          if (newDecls !== null) {
            merged.push({ ...aiRule, selectors: [selector], declarations: newDecls });
          }
        }
      });
    } else if (aiRule.type === "media" || aiRule.type === "supports") {
      const key = aiRule.type === "media" ? aiRule.media : aiRule.condition;
      const existingBlock = merged.find(
        (r) =>
          r.type === aiRule.type &&
          (r.media === key || r.condition === key)
      );

      if (existingBlock) {
        existingBlock.rules = mergeRules(existingBlock.rules, aiRule.rules);
      } else {
        const newBlock = { ...aiRule, rules: mergeRules([], aiRule.rules) };
        merged.push(newBlock);
      }
    }
  });

  return merged;
}

function consolidateRules(rules) {
  const selectorMap = new Map();

  rules.forEach((rule, index) => {
    if (rule.type === "rule") {
      rule.selectors.forEach((selector) => {
        if (selectorMap.has(selector)) {
          throw new Error(
            `Ambiguity: Selector "${selector}" found multiple times in original file. ` +
            `Use --view mode IDs to disambiguate.`
          );
        }
        selectorMap.set(selector, { rule, index });
      });
    } else if (rule.rules) {
      rule.rules = consolidateRules(rule.rules);
    }
  });

  return rules;
}

// --- CLI entrypoint ---
if (require.main === module) {
  const PROJECT_ROOT = process.env.PROJECT_ROOT || process.cwd();
  console.log("[LOG] Command line arguments:", process.argv);
  console.log("[LOG] PROJECT_ROOT environment variable:", process.env.PROJECT_ROOT || "Not set");

  // Handle --view mode
  if (process.argv[2] === "--view") {
    const filePath = process.argv[3];
    if (!filePath) {
      console.error("Usage: node merge_css.js --view <file>");
      process.exit(1);
    }

    const abs = path.resolve(PROJECT_ROOT, filePath);
    if (!fs.existsSync(abs)) {
      console.error(`File not found: ${abs}`);
      process.exit(1);
    }

    const original = fs.readFileSync(abs, "utf-8");
    const ast = css.parse(original || "", { source: "view" });
    addSelectorAnchors(ast);
    const formatted = css.stringify(ast, { compress: false });

    console.log(formatted);
    process.exit(0);
  }

  // --- Normal merge mode ---
  const [filesJsonPath, editsJsonPath] = process.argv.slice(2);

  if (!filesJsonPath || !editsJsonPath) {
    console.error("Usage: node merge_css.js <files.json> <ai_edits.json>");
    process.exit(1);
  }

  const filesJsonAbs = path.resolve(PROJECT_ROOT, filesJsonPath);
  const editsJsonAbs = path.resolve(PROJECT_ROOT, editsJsonPath);

  const files = JSON.parse(fs.readFileSync(filesJsonAbs, "utf-8"));
  const aiEdits = JSON.parse(fs.readFileSync(editsJsonAbs, "utf-8"));

  files.forEach((file) => {
    const absolutePath = path.resolve(PROJECT_ROOT, file.path);
    console.log(`[LOG] File to merge: ${file.path} -> ${absolutePath}`);
  });

  mergeAllFiles(files, aiEdits, PROJECT_ROOT);
}

module.exports = { mergeCSS, mergeAllFiles, addSelectorAnchors, stripSelectorAnchors };