export async function generateAllOutputs(content: WeeklyReportContent) {
  // 1) JSON snapshot (fuente única)
  const jsonSnapshot = JSON.stringify(content);

  // 2) Markdown (debug / export)
  const markdown = renderWeeklyReportMarkdown(content);

  // 3) HTML (web + base para PDF y email)
  const html = renderWeeklyReportHtml(content);

  // 4) PDF (Playwright headless desde el HTML)
  const pdfBuffer = await renderPdfFromHtml(html);
  const pdfStorageUri = await storePdfPrivate(pdfBuffer);

  // 5) Email resumen (corto + link + PDF adjunto)
  const emailPayload = buildEmailSummary(content, pdfStorageUri);

  return { jsonSnapshot, markdown, html, pdfStorageUri, emailPayload };
}

{
  "report": {
    "report_id": "rep_2026_w22",
    "report_code": "REP-WEEKLY-2026-W22",
    "company_id": "10000000-0000-0000-0000-000000000001",
    "company_name": "Empresa Demo Cuyo S.A.",
    "period_start": "2026-05-25",
    "period_end": "2026-05-31",
    "period_label": "Semana 22 · Mayo 2026",
    "generated_at": "2026-05-31T18:00:00-03:00",
    "generated_by": "Sistema FARO",
    "status": "generated",
    "payload_version": 1
  },
  "score": {
    "current": 66,
    "previous": 74,
    "delta": -8,
    "status": "warning",
    "main_drivers": ["TNS-001", "TNS-004", "TNS-006"],
    "potential_recovery": 16,
    "locked_by_evidence": 5
  },
  "executive_summary": {
    "headline": "La empresa creció en ventas, pero deterioró rentabilidad y caja.",
    "summary": "FARO detectó 6 tensiones activas, 2 críticas y 4 altas. El principal deterioro proviene de crecimiento no rentable, cobranza más lenta y stock crítico en alta rotación.",
    "risk_level": "high",
    "management_focus": "Recuperar margen, acelerar cobranza y resolver quiebres de stock.",
    "ai_audit": {
      "used_ai": true,
      "model": "sonnet-4-7",
      "slot_outputs": ["headline", "summary"],
      "fallback_used": false,
      "prompt_hash": "sha256:..."
    }
  },
  "tensions": {
    "total": 6,
    "critical": 2,
    "high": 4,
    "items": [
      {
        "tension_code": "TNS-001",
        "title": "Crecimiento no rentable",
        "severity": "critical",
        "score_impact": -8.5,
        "actions_open": 3,
        "actions_expired": 1
      }
    ]
  },
  "actions": {
    "total": 14,
    "open": 9,
    "closed": 5,
    "expired": 3,
    "blocked": 2,
    "without_evidence": 4,
    "items": []
  },
  "evidence": {
    "required": 12,
    "submitted": 6,
    "approved": 4,
    "rejected": 1,
    "missing": 7
  },
  "escalations": {
    "open": 2,
    "critical": 1,
    "items": []
  },
  "areas": [],
  "responsibles": [],
  "decisions_required": [],
  "recommendations": [],
  "next_week_focus": []
}

import { CronJob } from "cron";
import { generateWeeklyExecutiveReport } from "@/src/reports/generateWeeklyExecutiveReport";

// Todos los lunes a las 07:00 hora Mendoza
new CronJob(
  "0 7 * * 1",
  async () => {
    const companies = await db.query("SELECT company_id FROM faro.companies WHERE active = true");
    const { periodStart, periodEnd } = previousWeekRange("America/Argentina/Mendoza");

    for (const { company_id } of companies.rows) {
      try {
        await generateWeeklyExecutiveReport({
          client: await db.connect(),
          companyId: company_id,
          periodStart,
          periodEnd,
          generatedBy: null // system
        });
      } catch (error) {
        logger.error({ company_id, error }, "weekly_report_failed");
      }
    }
  },
  null,
  true,
  "America/Argentina/Mendoza"
).start();

// Desde botón "Generar reporte" en la UI del gerente
async function handleGenerateClick() {
  setLoading(true);
  try {
    const { report_id } = await generateWeeklyReport({
      periodStart: "2026-05-25",
      periodEnd: "2026-05-31"
    });
    router.push(`/faro/reports/${report_id}`);
  } catch (error) {
    toast.error("No se pudo generar el reporte. Reintentar.");
  } finally {
    setLoading(false);
  }
}

CREATE TABLE IF NOT EXISTS faro.reports (
  report_id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  company_id uuid NOT NULL,

  report_code text NOT NULL,
  report_type text NOT NULL CHECK (
    report_type IN (
      'weekly_executive',
      'daily_operational',
      'monthly_board',
      'tension_closure',
      'custom'
    )
  ),

  title text NOT NULL,
  period_start date NOT NULL,
  period_end date NOT NULL,
  period_label text NOT NULL,

  status text NOT NULL DEFAULT 'draft' CHECK (
    status IN ('draft', 'generated', 'sent', 'archived', 'failed')
  ),

  score_current numeric(9,2) NULL,
  score_previous numeric(9,2) NULL,
  score_delta numeric(9,2) NULL,

  headline text NULL,
  executive_summary text NULL,
  risk_level text NULL CHECK (
    risk_level IS NULL OR risk_level IN ('low', 'medium', 'high', 'critical')
  ),

  -- snapshot inmutable del reporte completo
  snapshot_payload jsonb NOT NULL DEFAULT '{}'::jsonb,
  metrics jsonb NOT NULL DEFAULT '{}'::jsonb,

  -- audit trail de IA (D5)
  ai_audit jsonb NOT NULL DEFAULT '{}'::jsonb,

  html_content text NULL,
  markdown_content text NULL,
  pdf_storage_uri text NULL,

  generated_by uuid NULL,
  generated_at timestamptz NULL,
  sent_by uuid NULL,
  sent_at timestamptz NULL,

  payload_version integer NOT NULL DEFAULT 1,

  created_at timestamptz NOT NULL DEFAULT now(),
  updated_at timestamptz NOT NULL DEFAULT now(),

  UNIQUE(company_id, report_code)
);

CREATE INDEX IF NOT EXISTS idx_reports_company_period
ON faro.reports(company_id, report_type, period_start DESC, period_end DESC);

CREATE INDEX IF NOT EXISTS idx_reports_snapshot
ON faro.reports USING gin(snapshot_payload);

ALTER TABLE faro.reports ENABLE ROW LEVEL SECURITY;

CREATE POLICY reports_company_isolation
ON faro.reports
USING (
  company_id::text = current_setting('app.company_id', true)
);

<!doctype html>
<html lang="es">
<head>
  <meta charset="utf-8" />
  <title>{{report_title}}</title>
  <style>
    :root {
      --faro-blue: #243F4A;
      --faro-gold: #C9A668;
      --faro-sand: #F6F1E8;
      --faro-border: rgba(36,63,74,.14);
      --faro-muted: rgba(36,63,74,.68);
    }
    body { margin: 0; font-family: Inter, Arial, sans-serif; color: var(--faro-blue); background: var(--faro-sand); }
    .page { max-width: 1040px; margin: 0 auto; padding: 42px; }
    .card { background: rgba(255,255,255,.78); border: 1px solid var(--faro-border); border-radius: 24px; padding: 28px; margin-bottom: 18px; }
    .eyebrow { color: var(--faro-gold); font-size: 11px; text-transform: uppercase; letter-spacing: .18em; font-weight: 700; }
    h1 { font-size: 40px; line-height: 1.05; margin: 12px 0 0; letter-spacing: -0.03em; }
    h2 { font-size: 24px; margin-bottom: 14px; letter-spacing: -0.03em; }
    .grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; }
    .metric { background: #F8F4EC; border: 1px solid var(--faro-border); border-radius: 18px; padding: 16px; }
    .metric-label { font-size: 11px; color: var(--faro-muted); text-transform: uppercase; letter-spacing: .12em; font-weight: 700; }
    .metric-value { font-size: 30px; font-weight: 700; margin-top: 8px; }
    table { width: 100%; border-collapse: collapse; font-size: 13px; }
    th { text-align: left; font-size: 11px; text-transform: uppercase; letter-spacing: .12em; color: var(--faro-muted); border-bottom: 1px solid var(--faro-border); padding: 10px 8px; }
    td { border-bottom: 1px solid rgba(36,63,74,.08); padding: 12px 8px; vertical-align: top; }
    .badge { display: inline-block; border-radius: 999px; padding: 4px 9px; font-size: 10px; text-transform: uppercase; font-weight: 800; border: 1px solid var(--faro-border); }
    .critical { background: #FEE2E2; color: #991B1B; }
    .high { background: #FEF3C7; color: #92400E; }
    .footer { color: var(--faro-muted); font-size: 11px; margin-top: 28px; text-align: center; }
  </style>
</head>
<body>
  <main class="page">
    {{content}}
  </main>
</body>
</html>

export function renderWeeklyReportHtml(content: WeeklyReportContent): string {
  return `
<section class="card">
  <div class="eyebrow">FARO Connect · Reporte Semanal Ejecutivo</div>
  <h1>${escapeHtml(content.report.company_name)}</h1>
  <p>${escapeHtml(content.report.period_label)}</p>

  <div class="grid">
    <div class="metric">
      <div class="metric-label">FARO Score</div>
      <div class="metric-value">${content.score.current}</div>
    </div>
    <div class="metric">
      <div class="metric-label">Variación</div>
      <div class="metric-value">${formatSigned(content.score.delta)}</div>
    </div>
    <div class="metric">
      <div class="metric-label">Riesgo</div>
      <div class="metric-value">${escapeHtml(content.executive_summary.risk_level)}</div>
    </div>
    <div class="metric">
      <div class="metric-label">Recuperación</div>
      <div class="metric-value">+${content.score.potential_recovery}</div>
    </div>
  </div>
</section>
`;
}

CREATE TABLE IF NOT EXISTS faro.report_recipients (
  report_recipient_id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  company_id uuid NOT NULL,
  report_id uuid NOT NULL,

  user_id uuid NULL,
  role_code text NULL,
  email text NULL,

  delivery_channel text NOT NULL CHECK (
    delivery_channel IN ('in_app', 'email', 'download')
  ),

  status text NOT NULL DEFAULT 'pending' CHECK (
    status IN ('pending', 'sent', 'read', 'failed', 'cancelled')
  ),

  sent_at timestamptz NULL,
  read_at timestamptz NULL,
  failure_reason text NULL,

  created_at timestamptz NOT NULL DEFAULT now()
);

CREATE INDEX IF NOT EXISTS idx_report_recipients_report
ON faro.report_recipients(company_id, report_id, status);

-- Al generar
SELECT faro.log_execution_event(
  $1,                                  -- company_id
  'report',                          -- entity_type
  $2,                                  -- report_id
  'weekly_report_generated',        -- event_type
  'report',                          -- event_family
  'Reporte semanal generado',        -- title
  $3,                                  -- description
  $4,                                  -- generated_by
  CASE WHEN $4 IS NULL THEN 'system' ELSE 'user' END,
  NULL, NULL, NULL, NULL, 'generated',
  NULL, NULL, NULL, NULL,
  'report_engine', $5, $6::jsonb
);

-- Al enviar
SELECT faro.log_execution_event(
  $1, 'report', $2,
  'weekly_report_sent',
  'report',
  'Reporte semanal enviado',
  'El reporte fue enviado por email.',
  $3, 'user',
  NULL, NULL, NULL, 'generated', 'sent',
  NULL, NULL, NULL, NULL,
  'report_engine', NULL, $4::jsonb
);

export async function POST(request: NextRequest) {
  const session = await getSessionContext();
  if (!session?.companyId || !session?.userId) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  const body = await request.json().catch(() => ({}));
  const periodStart = String(body.period_start ?? "");
  const periodEnd = String(body.period_end ?? "");

  if (!periodStart || !periodEnd) {
    return NextResponse.json({ error: "PERIOD_REQUIRED" }, { status: 400 });
  }

  const client = await db.connect();
  try {
    await client.query("BEGIN");
    await client.query(`SELECT set_config('app.company_id', $1, true)`, [session.companyId]);
    await client.query(`SELECT set_config('app.user_id', $1, true)`, [session.userId]);

    const result = await generateWeeklyExecutiveReport({
      client,
      companyId: session.companyId,
      periodStart,
      periodEnd,
      generatedBy: session.userId
    });

    await client.query("COMMIT");
    return NextResponse.json({ ok: true, report_id: result.reportId, content: result.content });
  } catch (error: any) {
    await client.query("ROLLBACK");
    return NextResponse.json({ error: error.message ?? "Could not generate weekly report" }, { status: 500 });
  } finally {
    client.release();
  }
}

export interface AIAuditTrail {
  used_ai: boolean;
  model: "sonnet-4-7" | "haiku-4-7" | null;
  slot_outputs: Array<"headline" | "summary" | "recommendations">;
  fallback_used: boolean;
  prompt_hash: string;          // SHA-256 del prompt usado
  response_hash: string;        // SHA-256 del raw response
  generated_at: string;
  cost_usd: number | null;
  refused_fields: string[];     // campos que el guard rechazó
}

// Si el modelo está caído, audit trail registra fallback
if (!aiAvailable) {
  content.executive_summary.headline = buildWeeklyHeadline(input);
  content.executive_summary.summary = buildExecutiveSummary(base, tensions, actions);
  content.executive_summary.ai_audit = {
    used_ai: false,
    model: null,
    slot_outputs: [],
    fallback_used: true,
    prompt_hash: "",
    response_hash: "",
    generated_at: new Date().toISOString(),
    cost_usd: null,
    refused_fields: []
  };
}

export function buildWeeklyHeadline(input: {
  scoreCurrent: number;
  scoreDelta: number;
  criticalTensions: number;
  expiredActions: number;
  topTensionTitle?: string | null;
}): string {
  if (input.scoreDelta <= -8 && input.criticalTensions > 0) {
    return `La empresa deterioró su salud ejecutiva por tensiones críticas no resueltas.`;
  }
  if (input.topTensionTitle) {
    return `El foco semanal debe estar en ${input.topTensionTitle}.`;
  }
  if (input.expiredActions > 0) {
    return `La principal alerta semanal está en acciones vencidas.`;
  }
  if (input.scoreDelta > 0) {
    return `La empresa mejora su Score por avance en ejecución y cierre de acciones.`;
  }
  return `La empresa mantiene estabilidad, con focos operativos pendientes.`;
}

import type pg from "pg";
import { buildWeeklyHeadline, classifyWeeklyRisk } from "./weeklyReportRules";
import { renderWeeklyReportHtml } from "./renderWeeklyReportHtml";
import { renderWeeklyReportMarkdown } from "./renderWeeklyReportMarkdown";
import { callAiGatewayForSlot } from "@/src/ai/gateway";

export async function generateWeeklyExecutiveReport(params: {
  client: pg.PoolClient;
  companyId: string;
  periodStart: string;
  periodEnd: string;
  generatedBy?: string | null;
}) {
  // 1) Lectura base · todos los datos vienen del motor
  const base = await getWeeklyBase(params.client, params.companyId, params.periodStart, params.periodEnd);
  const tensions = await getTopTensions(params.client, params.companyId);
  const actions = await getCriticalActions(params.client, params.companyId);
  const escalations = await getOpenEscalations(params.client, params.companyId);
  const decisions = await getDecisionsRequired(params.client, params.companyId);
  const events = await getWeeklyEvents(params.client, params.companyId, params.periodStart, params.periodEnd);

  // 2) Reglas determinísticas
  const topTension = tensions[0] ?? null;
  const headlineFallback = buildWeeklyHeadline({
    scoreCurrent: Number(base.score_current ?? 0),
    scoreDelta: Number(base.score_delta ?? 0),
    criticalTensions: Number(base.critical_tensions ?? 0),
    expiredActions: Number(base.expired_actions ?? 0),
    topTensionTitle: topTension?.title ?? null
  });
  const riskLevel = classifyWeeklyRisk({
    scoreCurrent: Number(base.score_current ?? 0),
    criticalTensions: Number(base.critical_tensions ?? 0),
    expiredActions: Number(base.expired_actions ?? 0),
    openEscalations: Number(base.open_escalations ?? 0)
  });

  // 3) IA controlada · slots con audit trail (D5)
  const aiResult = await callAiGatewayForSlot({
    slots: ["headline", "summary", "recommendations"],
    payloadFingerprint: { base, tensions, actions, escalations, decisions },
    fallback: { headline: headlineFallback }
  });

  // 4) Compilación del content (fuente única)
  const content = {
    report: { /* metadata + UUID + payload_version */ },
    score: { /* current, previous, delta, status, recovery */ },
    executive_summary: {
      headline: aiResult.headline,
      summary: aiResult.summary,
      risk_level: riskLevel,
      management_focus: buildManagementFocus(tensions),
      ai_audit: aiResult.audit
    },
    tensions, actions, escalations, decisions_required: decisions, events
  };

  // 5) Render multi-formato + persistencia inmutable
  const markdown = renderWeeklyReportMarkdown(content);
  const html = renderWeeklyReportHtml(content);
  const reportId = await persistReportSnapshot(params.client, content, html, markdown, params.generatedBy);

  // 6) Timeline event
  await logWeeklyReportGenerated(params.client, params.companyId, reportId, content);

  return { reportId, content, html, markdown };
}

async function getWeeklyBase(client: pg.PoolClient, companyId: string, periodStart: string, periodEnd: string) {
  const result = await client.query(
    `SELECT * FROM faro.v_weekly_report_base
     WHERE company_id = $1 AND period_start = $2::date AND period_end = $3::date
     LIMIT 1`,
    [companyId, periodStart, periodEnd]
  );
  if (!result.rows[0]) throw new Error("WEEKLY_REPORT_BASE_NOT_FOUND");
  return result.rows[0];
}

async function getTopTensions(client: pg.PoolClient, companyId: string) {
  const result = await client.query(
    `SELECT
       t.tension_id, t.tension_code,
       COALESCE(t.title, td.name) AS title,
       t.severity, t.priority_score, t.confidence_score, t.status, t.score_impact,
       td.business_question, td.executive_diagnosis, td.area_code, td.module_code,
       COUNT(a.action_id) AS actions_total,
       COUNT(a.action_id) FILTER (WHERE a.status NOT IN ('closed','cancelled','rejected')) AS actions_open,
       COUNT(a.action_id) FILTER (WHERE a.status = 'closed') AS actions_closed,
       COUNT(a.action_id) FILTER (WHERE a.status NOT IN ('closed','cancelled','rejected') AND a.due_date < CURRENT_DATE) AS actions_expired
     FROM faro.tensions t
     LEFT JOIN faro.tension_definitions td ON td.tension_code = t.tension_code AND td.status = 'active'
     LEFT JOIN faro.actions a ON a.company_id = t.company_id AND a.tension_id = t.tension_id
     WHERE t.company_id = $1 AND t.status NOT IN ('closed','rejected')
     GROUP BY t.tension_id, t.tension_code, t.title, td.name, t.severity, t.priority_score,
              t.confidence_score, t.status, t.score_impact, td.business_question,
              td.executive_diagnosis, td.area_code, td.module_code
     ORDER BY CASE t.severity
       WHEN 'critical' THEN 1 WHEN 'high' THEN 2 WHEN 'medium' THEN 3 WHEN 'low' THEN 4 ELSE 5
     END, t.priority_score DESC
     LIMIT 10`,
    [companyId]
  );
  return result.rows;
}

export function classifyWeeklyRisk(input: {
  scoreCurrent: number;
  criticalTensions: number;
  expiredActions: number;
  openEscalations: number;
}): "low" | "medium" | "high" | "critical" {
  if (
    input.scoreCurrent < 60 ||
    input.criticalTensions >= 3 ||
    input.openEscalations >= 3
  ) return "critical";

  if (
    input.scoreCurrent < 75 ||
    input.criticalTensions >= 1 ||
    input.expiredActions >= 2
  ) return "high";

  if (input.scoreCurrent < 85) return "medium";

  return "low";
}

ALTER TABLE faro.reports ENABLE ROW LEVEL SECURITY;

-- Aislamiento estricto por company
CREATE POLICY reports_company_isolation
ON faro.reports
USING (
  company_id::text = current_setting('app.company_id', true)
);

-- Solo roles de dirección pueden insertar reportes manuales
CREATE POLICY reports_insert_by_role
ON faro.reports
FOR INSERT
WITH CHECK (
  company_id::text = current_setting('app.company_id', true)
  AND (
    current_setting('app.role_codes', true) LIKE '%general_manager%'
    OR current_setting('app.role_codes', true) LIKE '%director%'
    OR current_setting('app.user_id', true) = ''  -- sistema (cron)
  )
);

-- Reportes archivados son solo lectura
CREATE POLICY reports_no_update_when_archived
ON faro.reports
FOR UPDATE
USING (status <> 'archived');

import { describe, expect, it } from "vitest";
import { withTestDbContext } from "../src/helpers/dbTestContext";
import { generateWeeklyExecutiveReport } from "../src/reports/generateWeeklyExecutiveReport";

describe("Weekly executive report", () => {
  it("generates weekly report with score and tensions", async () => {
    await withTestDbContext(
      {
        companyId: "10000000-0000-0000-0000-000000000001",
        userId: "12000000-0000-0000-0000-000000000001",
        roleCodes: ["general_manager"]
      },
      async (client) => {
        const result = await generateWeeklyExecutiveReport({
          client,
          companyId: "10000000-0000-0000-0000-000000000001",
          periodStart: "2026-05-25",
          periodEnd: "2026-05-31",
          generatedBy: "12000000-0000-0000-0000-000000000001"
        });

        expect(result.reportId).toBeTruthy();
        expect(result.content.score.current).toBeGreaterThanOrEqual(0);
        expect(result.markdown).toContain("Reporte Semanal Ejecutivo");
        expect(result.content.executive_summary.ai_audit).toBeDefined();
      }
    );
  });

  it("falls back without AI when gateway is down", async () => {
    process.env.AI_GATEWAY_FORCE_FALLBACK = "true";
    await withTestDbContext({ /* ... */ }, async (client) => {
      const result = await generateWeeklyExecutiveReport({ client, /* ... */ } as any);
      expect(result.content.executive_summary.ai_audit.fallback_used).toBe(true);
      expect(result.content.executive_summary.headline).toBeTruthy();
    });
  });
});

app/
  faro/
    reports/
      weekly/
        page.tsx                        // listado + botón "Generar"
      [id]/
        page.tsx                        // detalle del reporte

components/reports/
  WeeklyReportPage.tsx                  // orquestador
  WeeklyReportHeader.tsx                // bloque 01
  WeeklyReportExecutiveSummary.tsx      // bloque 02
  WeeklyReportScoreCard.tsx             // bloque 03
  WeeklyReportTensionsTable.tsx         // bloque 04
  WeeklyReportActionsTable.tsx          // bloque 05
  WeeklyReportEvidenceBlock.tsx         // bloque 06
  WeeklyReportEscalationsTable.tsx      // bloque 07
  WeeklyReportAreasTable.tsx            // bloque 08
  WeeklyReportResponsiblesTable.tsx     // bloque 09
  WeeklyReportDecisions.tsx             // bloque 10
  WeeklyReportRecommendations.tsx       // bloque 11
  WeeklyReportNextFocus.tsx             // bloque 12
  WeeklyReportActionsBar.tsx            // botones generar/enviar/descargar PDF
  WeeklyReportEmptyState.tsx            // helper reutilizable

lib/faro/
  reports.types.ts                      // tipos compartidos
  reports.api.ts                        // client REST

export type WeeklyReportResponse = {
  report_id: string;
  report_code: string;
  report_type: "weekly_executive";
  title: string;
  period_start: string;
  period_end: string;
  period_label: string;
  status: "draft" | "generated" | "sent" | "archived" | "failed";
  score_current: number;
  score_previous: number;
  score_delta: number;
  headline: string;
  executive_summary: string;
  risk_level: "low" | "medium" | "high" | "critical";
  content: WeeklyReportContent;
  html_content: string | null;
  markdown_content: string | null;
  generated_at: string | null;
  sent_at: string | null;
};

export type WeeklyReportContent = {
  report: { report_code: string; company_name: string; period_label: string; generated_at: string };
  score: { current: number; previous: number; delta: number; status: string; potential_recovery: number };
  executive_summary: {
    headline: string;
    summary: string;
    risk_level: "low" | "medium" | "high" | "critical";
    management_focus: string;
    ai_audit: AIAuditTrail;
  };
  tensions: WeeklyReportTension[];
  actions: WeeklyReportAction[];
  escalations: WeeklyReportEscalation[];
  decisions_required: WeeklyReportDecision[];
  events: unknown[];
};

"use client";

import type { WeeklyReportResponse } from "@/lib/faro/reports.types";
import { WeeklyReportHeader } from "./WeeklyReportHeader";
import { WeeklyReportExecutiveSummary } from "./WeeklyReportExecutiveSummary";
import { WeeklyReportScoreCard } from "./WeeklyReportScoreCard";
import { WeeklyReportTensionsTable } from "./WeeklyReportTensionsTable";
import { WeeklyReportActionsTable } from "./WeeklyReportActionsTable";
import { WeeklyReportEscalationsTable } from "./WeeklyReportEscalationsTable";
import { WeeklyReportDecisions } from "./WeeklyReportDecisions";
import { WeeklyReportRecommendations } from "./WeeklyReportRecommendations";
import { WeeklyReportNextFocus } from "./WeeklyReportNextFocus";

export function WeeklyReportPage({ report }: { report: WeeklyReportResponse }) {
  return (
    <main className="min-h-screen bg-[#F6F1E8] px-4 py-6 text-[#243F4A] md:px-8">
      <div className="mx-auto flex max-w-6xl flex-col gap-5">
        <WeeklyReportHeader report={report} />
        <div className="grid gap-5 lg:grid-cols-[.9fr_1.1fr]">
          <WeeklyReportScoreCard score={report.content.score} />
          <WeeklyReportExecutiveSummary summary={report.content.executive_summary} />
        </div>
        <WeeklyReportTensionsTable tensions={report.content.tensions} />
        <WeeklyReportActionsTable actions={report.content.actions} />
        <WeeklyReportEscalationsTable escalations={report.content.escalations} />
        <WeeklyReportDecisions decisions={report.content.decisions_required} />
        <WeeklyReportRecommendations content={report.content} />
        <WeeklyReportNextFocus content={report.content} />
      </div>
    </main>
  );
}