import Card from '../../src/components/Card';
import { guidesNav } from '../../nav/guides';

{/*
  User Guides landing page.

  Groupings and ordering come from nav/guides.ts — the single source of truth,
  so this page and the left sidebar always match. Per-card copy lives in META
  below, keyed by the nav `file` path; per-section overview text lives in
  GROUP_BLURBS. To add a guide: add it to a category in nav/guides.ts, then add
  a META entry (summary + lucide icon) here.
*/}

export const GROUP_BLURBS = {
  'Core Concepts': 'New to Monad? Start here — how pipelines ingest, shape, route, and monitor your security data end to end.',
  'Account & Access': 'Manage API access and role-based permissions across your organization — keys, rate limits, billing, and org RBAC.',
  'Connecting Data Sources': 'Get data into Monad — authenticate to your sources, tune how often inputs sync, and catch upstream schema changes.',
  'Data Operations': 'Operate and tune running pipelines — optimization, delivery reliability, data residency, resource sharing, and cost.',
  'Security & Compliance': 'How Monad secures your data, manages secrets, and supports self-managed deployments.',
  'Solution Guides': 'End-to-end walkthroughs for common security use cases, from audit-log visibility to vulnerability management.',
};

export const META = {
  // Core Concepts
  'guides/what-are-pipelines': { summary: 'How Monad connects inputs, transforms, enrichments, and outputs into one directed data pipeline.', icon: 'waypoints' },
  'guides/enrichment-normalization-routing': { summary: 'Add context, standardize heterogeneous data, and send records to the right destinations.', icon: 'route' },
  'guides/monitoring-and-alerting': { summary: 'Watch pipeline health, configure alert rules, and detect schema drift across your pipelines.', icon: 'activity' },
  'guides/orgs-teams-resource-sharing': { summary: 'Understand root orgs, teams, roles, and how resources flow one way across your hierarchy.', icon: 'network' },
  // Account & Access
  'guides/api-keys': { summary: 'Create and manage org-scoped API keys for programmatic access to the Monad API.', icon: 'key-round' },
  'guides/rate-limiting': { summary: "Cap a connector's outbound request rate to stay under a source API's quota and avoid 429s.", icon: 'gauge' },
  'guides/billing-rbac': { summary: 'Control who can manage billing accounts, assign organizations, and configure billing roles.', icon: 'wallet' },
  'guides/organization-rbac': { summary: 'Control who can do what in your org with roles and granular permissions.', icon: 'shield-check' },
  'guides/mcp-usage': { summary: 'Connect an MCP client to Monad and manage your pipelines in natural language.', icon: 'bot' },
  // Connecting Data Sources
  'inputs/aws/index': { summary: 'Authenticate Monad to AWS — role assumption, static keys, and OIDC web identity.', icon: 'cloud' },
  'guides/sync-frequency': { summary: 'How often each input syncs by default, what sets its cadence, and how to override it.', icon: 'refresh-cw' },
  'guides/schema-detection': { summary: 'Learn the shape of data on a pipeline edge and alert when fields or types change.', icon: 'radar' },
  // Data Operations
  'guides/smart-optimizer': { summary: 'Use the AI transform assistant to suggest dropping low-value fields and masking PII.', icon: 'sparkles' },
  'guides/egress-ip-addresses': { summary: 'The fixed Monad SaaS egress IPs to add to your source and destination allowlists.', icon: 'globe' },
  'guides/record-location': { summary: "Use GJSON path syntax to extract records nested inside an input's JSON payload.", icon: 'map-pin' },
  'guides/reliability': { summary: 'How Monad buffers, applies back-pressure, and guarantees at-least-once delivery.', icon: 'shield-check' },
  'guides/resource-sharing': { summary: 'Share inputs, outputs, transforms, enrichments, and secrets one way with your teams.', icon: 'share-2' },
  'guides/storage-costs': { summary: 'See the storage spend Monad avoids by filtering noise before it reaches your destinations.', icon: 'dollar-sign' },
  // Security & Compliance
  'guides/secrets': { summary: 'Store credentials once, reference them from any component, and manage their lifecycle.', icon: 'lock' },
  'guides/security': { summary: 'How Monad encrypts data in transit and at rest, and how it handles and retains your data.', icon: 'shield' },
  // Solution Guides
  'guides/aws-rds-audit-visibility': { summary: 'Enable RDS audit logging and route it to CloudWatch for Monad to ingest.', icon: 'database' },
  'guides/aws-redshift-audit-visibility': { summary: 'Enable Redshift audit logging and route it to CloudWatch or S3 for Monad to ingest.', icon: 'database' },
  'guides/isv': { summary: 'Enhance detection and alerting by routing Okta and Google Workspace events through Monad.', icon: 'radar' },
  'guides/secOps': { summary: 'Transform AWS CloudTrail logs and route IAM events to the right teams to cut cost and noise.', icon: 'shield-alert' },
  'guides/vulnerability_management': { summary: 'Prioritize vulnerability findings and route them to the teams best placed to remediate.', icon: 'bug' },
  // Solution Guides → Self-Managed Deployment
  'guides/customer_helm_install': { summary: 'Install Monad into a Kubernetes cluster with Helm, including prerequisites and ingress.', icon: 'ship' },
  'guides/metrics': { summary: 'The Prometheus metrics worth watching per component and pipeline pod, with worked alert rules.', icon: 'gauge' },
  'guides/architecture': { summary: "A map of Monad's components and data flow for operators running it in their own cluster.", icon: 'server' },
  'guides/troubleshooting': { summary: 'Diagnose common issues in a self-managed Monad deployment with kubectl.', icon: 'wrench' },
};

export const toCard = (d) => ({
  label: d.label,
  to: '/docs/' + d.file,
  summary: (META[d.file] || {}).summary || '',
  icon: (META[d.file] || {}).icon,
});

export const sections = guidesNav
  .filter((entry) => entry.type === 'category')
  .map((cat) => ({
    label: cat.label,
    blurb: GROUP_BLURBS[cat.label] || '',
    docs: (cat.items || []).filter((i) => i.type === 'doc').map(toCard),
    subgroups: (cat.items || [])
      .filter((i) => i.type === 'category')
      .map((sc) => ({
        label: sc.label,
        docs: (sc.items || []).filter((i) => i.type === 'doc').map(toCard),
      })),
  }));

export const CardGrid = ({ docs }) => (
  <div className="grid sm:grid-cols-2 gap-5 grid-cols-1">
    {docs.map((d) => (
      <Card key={d.to} component={d.label} description={d.summary} to={d.to} icon={d.icon} />
    ))}
  </div>
);

# User Guides

Task-focused guides for building and operating security data pipelines in Monad. Browse by area below, or use the sidebar to jump straight to a topic.

{sections.map((s) => (
  <section key={s.label} className="mb-10">
    <h2>{s.label}</h2>
    <p className="text-md">{s.blurb}</p>
    <CardGrid docs={s.docs} />
    {s.subgroups.map((sg) => (
      <div key={sg.label} className="mt-6">
        <h3>{sg.label}</h3>
        <CardGrid docs={sg.docs} />
      </div>
    ))}
  </section>
))}