// SPDX-License-Identifier: MIT

import jmespath from "jmespath";

import { toMarkdownTable } from "../markdown.js";

export function outputFiltered(object, query) {
  return query
    ? jmespath.search(object, query)
    : object;
}

export function parseHeaderSpec(headerValue) {
  if (!headerValue) {
    return { mode: "default" };
  }

  const raw = headerValue.trim();
  if (raw === "" || raw.toLowerCase() === "auto" || raw.toLowerCase() === "a") {
    return { mode: "auto" };
  }

  const parts = raw.split(",").map((p) => p.trim()).filter(Boolean);
  const isMap = parts.some((p) => p.includes(":"));

  if (!isMap) {
    return { mode: "list", labels: parts };
  }

  const map = {};
  for (const part of parts) {
    const idx = part.indexOf(":");
    if (idx < 0) {
      throw new Error(`Invalid --header mapping segment: '${part}'`);
    }
    const key = part.slice(0, idx).trim();
    const label = part.slice(idx + 1).trim();
    if (!key || !label) {
      throw new Error(`Invalid --header mapping segment: '${part}'`);
    }
    map[key] = label;
  }

  return { mode: "map", map };
}

export function normalizeOutputFormat(outputValue) {
  const raw = (outputValue ?? "json").toLowerCase();
  if (raw === "json" || raw === "j") return "json";
  if (raw === "table" || raw === "t") return "table";
  if (raw === "alignedtable" || raw === "at") return "alignedtable";
  if (raw === "prettytable" || raw === "pt") return "prettytable";
  throw new Error("--output must be one of: json|j, table|t, alignedtable|at, prettytable|pt");
}

export function omitPermissionGuidColumns(value) {
  if (Array.isArray(value)) {
    return value.map((item) => omitPermissionGuidColumns(item));
  }
  if (!value || typeof value !== "object") {
    return value;
  }
  const { resourceAppId, permissionId, ...rest } = value;
  return rest;
}

export async function readJsonFromStdin() {
  const input = await new Promise((resolve, reject) => {
    let data = "";
    process.stdin.setEncoding("utf8");
    process.stdin.on("data", (chunk) => {
      data += chunk;
    });
    process.stdin.on("end", () => {
      resolve(data);
    });
    process.stdin.on("error", (err) => {
      reject(err);
    });
  });
  if (!input.trim()) {
    throw new Error("No JSON input provided on stdin");
  }

  try {
    return JSON.parse(input);
  } catch (err) {
    throw new Error(`Invalid JSON input on stdin: ${err.message}`);
  }
}

export function renderOutput(command, output, outputFormat, headerSpec) {
  if (command === "table") {
    console.log(toMarkdownTable(
      output,
      outputFormat === "alignedtable" || outputFormat === "prettytable",
      outputFormat === "prettytable",
      headerSpec,
    ));
  } else if (outputFormat === "alignedtable") {
    console.log(toMarkdownTable(output, true, false, headerSpec));
  } else if (outputFormat === "prettytable") {
    console.log(toMarkdownTable(output, true, true, headerSpec));
  } else if (outputFormat === "table") {
    console.log(toMarkdownTable(output, false, false, headerSpec));
  } else {
    console.log(JSON.stringify(output, null, 2));
  }
}