import type { Business, TaskAutomationFlow } from "@/lib/types";

function topOpportunity(business: Business) {
  return [...business.opportunities].sort((a, b) => b.estimatedValue - a.estimatedValue)[0];
}

function parseIntegration(integrationTarget: string) {
  const cleaned = integrationTarget.replace(/^Mock:\s*/i, "").trim();
  const primary = cleaned.split("/")[0]?.trim() ?? cleaned;
  return { full: cleaned, primary };
}

function baseFlow(
  business: Business,
  roleName: string,
  integrationTarget: string,
  integrationAction: string,
  outputLabel: string,
  outputDetail: string,
  extraContext?: string,
): Omit<TaskAutomationFlow, "steps"> & { stepDetails: [string, string, string, string] } {
  const opp = topOpportunity(business);
  const { full, primary } = parseIntegration(integrationTarget);
  return {
    trigger: `You click Run task — ${roleName} agent activates`,
    stepDetails: [
      `Load ${business.input.businessName} Business Brain (opportunities, profile, competitors)`,
      extraContext ?? `Focus on "${opp?.title ?? business.metrics.topPriorityToday}" · $${business.metrics.revenuePotential.toLocaleString()} pipeline`,
      `Push to ${full} — ${integrationAction}`,
      `Save receipt + ${outputLabel} for your review`,
    ],
    integrationName: primary,
    integrationAction,
    mode: "demo",
    outputLabel,
    outputDetail,
    requiresApproval: true,
    approvalNote: "Nothing goes live until you approve the receipt (connect integrations in Settings to push automatically).",
  };
}

function toFlow(base: ReturnType<typeof baseFlow>): TaskAutomationFlow {
  return {
    trigger: base.trigger,
    steps: [
      { id: "context", label: "1. Context", detail: base.stepDetails[0] },
      { id: "generate", label: "2. Generate", detail: base.stepDetails[1] },
      { id: "integrate", label: "3. Integrate", detail: base.stepDetails[2] },
      { id: "receipt", label: "4. Receipt", detail: base.stepDetails[3] },
    ],
    integrationName: base.integrationName,
    integrationAction: base.integrationAction,
    mode: base.mode,
    outputLabel: base.outputLabel,
    outputDetail: base.outputDetail,
    requiresApproval: base.requiresApproval,
    approvalNote: base.approvalNote,
  };
}

const FLOW_BY_TASK: Record<
  string,
  (business: Business, roleName: string, integrationTarget: string) => TaskAutomationFlow
> = {
  "draft-social-post": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "schedule post draft to Meta Business Suite / LinkedIn",
        "Social post draft",
        "Ready-to-publish copy with CTA tied to your top opportunity",
        `Draft post copy for ${b.input.location} audience using recommendation templates`,
      ),
    ),
  "geo-ad-copy": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "create ad set draft with geo radius on your service area",
        "Ad copy + geo config",
        `Headlines, body, CTA, and $25–50/day test budget suggestion for ${b.input.location}`,
      ),
    ),
  "landing-headline": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "publish headline variant to CMS draft (Webflow, WordPress, etc.)",
        "Landing headline",
        "Conversion-focused hero line aligned to brand positioning",
      ),
    ),
  "review-responses": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "post replies to Google Business Profile review inbox",
        "Review responses",
        "Personalized replies for recent 3–5★ reviews",
      ),
    ),
  "review-requests": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "send SMS/email batch via Twilio or SendGrid with review links",
        "Review request batch",
        "Personalized messages to recent customers with tracking links",
      ),
    ),
  "reputation-report": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "pull rating trends into weekly reputation digest",
        "Reputation snapshot",
        `Trust score vs ${b.competitors[0]?.name ?? "competitors"} with action items`,
      ),
    ),
  "outreach-dm": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "log outreach in CRM and queue LinkedIn/email send",
        "Outreach messages",
        "Personalized DMs/emails for hot leads from your opportunity queue",
      ),
    ),
  "follow-up-sequence": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "activate 3-touch workflow in HubSpot / GoHighLevel",
        "Follow-up sequence",
        "Day 0, 2, and 5 emails/SMS for unanswered inquiries",
      ),
    ),
  "proposal-outline": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "generate proposal doc in PandaDoc / Proposify",
        "Proposal outline",
        "Scope, pricing tiers, timeline, and next-step CTA",
      ),
    ),
  "lead-callback-list": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "sync prioritized list to CRM tasks + optional Slack alert",
        "Callback queue",
        "Ranked leads with urgency tags and suggested call scripts",
      ),
    ),
  "schedule-optimization": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "block calendar slots in Google Calendar / field service software",
        "Schedule blocks",
        "Protected high-value windows for callbacks and estimates",
      ),
    ),
  "ops-digest": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "deliver digest via Slack or email to owner/ops",
        "Operations digest",
        "Open jobs, SLAs, bottlenecks, and today's priority",
      ),
    ),
  "reactivation-sms": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "queue SMS campaign in Twilio with merge fields",
        "Reactivation SMS",
        "Win-back texts to lapsed customers with offer code",
      ),
    ),
  "appointment-reminders": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "send reminder SMS/email 24h before appointments",
        "Appointment reminders",
        "Confirm/reply handling to reduce no-shows",
      ),
    ),
  "intake-summary": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "aggregate form/CRM inbox into prioritized intake board",
        "Intake summary",
        "New leads ranked with recommended next actions",
      ),
    ),
  "compliance-checklist": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "store checklist in document vault / Notion",
        "Compliance checklist",
        `${b.input.industryCategory} audit-ready checklist with status markers`,
      ),
    ),
  "rfp-doc-prep": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "assemble RFP packet for procurement portal upload",
        "RFP documentation",
        "Cover letter, pricing, compliance appendix for active RFP",
      ),
    ),
  "crm-audit": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "scan CRM pipeline and create follow-up tasks for stale deals",
        "CRM audit report",
        "Stale leads, missing follow-ups, and recommended CRM updates",
      ),
    ),
  "automation-workflow": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "export workflow map to Zapier / Make as importable template",
        "Automation workflow",
        "Trigger → action map for lead nurture or onboarding",
      ),
    ),
  "leader-priority-lock": (b, r, i) =>
    toFlow({
      ...baseFlow(
        b,
        r,
        i,
        "pin priority to BrandLxft Action Center + notify owner",
        "Locked priority",
        `Single focus: ${b.metrics.topPriorityToday}`,
      ),
      requiresApproval: false,
      approvalNote: "Leadership tasks update your dashboard immediately — no external push.",
    }),
  "leader-role-assignments": (b, r, i) =>
    toFlow({
      ...baseFlow(
        b,
        r,
        i,
        "delegate tasks to digital role agents in BrandLxft",
        "Role assignments",
        "Who owns what today across your digital team",
      ),
      requiresApproval: false,
      approvalNote: "Assignments appear in Role Agents — run each delegated role when ready.",
    }),
  "leader-accountability": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "send accountability DM via Slack or email",
        "Accountability check-in",
        "Deadline, expectations, and revenue at stake for the owner",
      ),
    ),
  "leader-standup-brief": (b, r, i) =>
    toFlow({
      ...baseFlow(
        b,
        r,
        i,
        "publish standup brief to BrandLxft Dashboard",
        "Standup brief",
        "What ships before noon, blockers, and delegated roles",
      ),
      requiresApproval: false,
      approvalNote: "Brief is saved to your dashboard feed.",
    }),
  "social-analysis-posts": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "queue 3-post draft pack in Meta Business Suite",
        "Social post pack",
        `3 posts from visibility ${b.socialMediaAnalysis?.visibilityScore ?? "—"}/100 and pick-share ${b.socialMediaAnalysis?.yourPickSharePercent ?? "—"}% analysis`,
        `Load social media analysis — top recommendation: ${b.socialMediaAnalysis?.recommendations[0]?.title ?? "visibility gap"}`,
      ),
    ),
  "social-trust-sync": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "save trust-sync copy to CMS draft + Meta pinned post draft",
        "Trust alignment content",
        `Website ${b.socialMediaAnalysis?.trust.websiteTrustScore ?? "—"}/100 vs social ${b.socialMediaAnalysis?.trust.socialTrustScore ?? "—"}/100 — unified messaging`,
        `Compare trust channels — ${b.socialMediaAnalysis?.trust.strongerChannel ?? "balanced"} leads`,
      ),
    ),
  "social-competitive-beat": (b, r, i) =>
    toFlow(
      baseFlow(
        b,
        r,
        i,
        "schedule comparison post draft in Meta / LinkedIn",
        "Competitive social post",
        `Leverage ${b.socialMediaAnalysis?.yourPickSharePercent ?? "—"}% pick share vs ${b.socialMediaAnalysis?.pickShare.find((p) => !p.isYou)?.name ?? "competitor"}`,
        `Draft implied comparison post — no competitor name in public copy`,
      ),
    ),
};

export function getTaskAutomationFlow(
  taskId: string,
  business: Business,
  roleName: string,
  integrationTarget: string,
): TaskAutomationFlow {
  const builder = FLOW_BY_TASK[taskId];
  if (builder) return builder(business, roleName, integrationTarget);

  const { full, primary } = parseIntegration(integrationTarget);
  return {
    trigger: `You click Run task — ${roleName} agent activates`,
    steps: [
      { id: "context", label: "1. Context", detail: `Load ${business.input.businessName} Business Brain` },
      { id: "generate", label: "2. Generate", detail: `AI builds deliverable for ${business.metrics.topPriorityToday}` },
      { id: "integrate", label: "3. Integrate", detail: `Push to ${full} when connected` },
      { id: "receipt", label: "4. Receipt", detail: "Save output for your review and approval" },
    ],
    integrationName: primary,
    integrationAction: "execute configured action",
    mode: "demo",
    outputLabel: "Task deliverable",
    outputDetail: "Personalized output saved as a receipt",
    requiresApproval: true,
    approvalNote: "Approve before anything goes live externally.",
  };
}

export const PLATFORM_AUTOMATION_OVERVIEW = {
  title: "How BrandLxft automates digital roles",
  stages: [
    { label: "Business Brain", detail: "Opportunities, competitors, profile, and your role context" },
    { label: "Role Agent", detail: "Digital role picks the right task for today's revenue move" },
    { label: "AI Execute", detail: "Generates copy, lists, workflows, and docs personalized to you" },
    { label: "Integration", detail: "Pushes to CRM, ads, SMS, email, CMS when you connect Settings" },
    { label: "Receipt", detail: "Summary + artifact you approve before anything goes live" },
  ],
};