import { appFormats, developmentModules } from "@/data/commercial";
import {
  appObjectives,
  businessTypes,
  optionalAddons,
  platformOptions,
} from "@/data/onboarding";
import type { Addon, Plan } from "@/types/plan";
import {
  appTypes,
  optionalServices,
  projectFeatures,
  planningPlatforms,
  visualStyles,
} from "@/data/projectPlanning";
import type {
  BillingCycle,
  CommercialQuote,
  DiscoveryState,
  PlanningProjectState,
} from "@/types/commerce";
import { addonToDisplayItem } from "@/lib/addonDisplay";
import { findPlanningPlanView } from "@/lib/planningPlans";

export type ProposalStatus = "draft" | "proposal" | "contracted";

export interface ClientProposalSnapshot {
  id: string;
  userId: number;
  createdAt: string;
  updatedAt: string;
  status: ProposalStatus;
  discovery: DiscoveryState;
  subscriptionSlug: string;
  planName: string;
  planId?: number;
  appFormatId: string;
  developmentModuleIds: string[];
  optionalAddonIds: string[];
  billingCycle: BillingCycle;
  includeStrategicPlanning: boolean;
  planning?: PlanningProjectState;
  paymentGateway?: string;
  sessionId?: string;
  quote: CommercialQuote;
  paymentStatus?: "pending" | "paid";
  projectStatus?: "draft" | "planning" | "development";
}

export interface ClientPaymentRecord {
  id: string;
  date: string;
  amount: number;
  method: string;
  status: "paid" | "pending" | "failed";
  sessionId?: string;
}

export function buildProposalLabels(
  discovery: DiscoveryState,
  developmentModuleIds: string[],
  optionalAddonIds: string[],
  catalogAddons: Addon[],
) {
  const business = businessTypes.find((b) => b.id === discovery.businessType);
  const objective = appObjectives.find((o) => o.id === discovery.appObjective);
  const platforms = platformOptions
    .filter((p) => discovery.platforms.includes(p.id))
    .map((p) => p.label);
  const modules = developmentModules
    .filter((m) => developmentModuleIds.includes(m.id))
    .map((m) => m.name);

  const addonItems =
    catalogAddons.length > 0
      ? catalogAddons
          .filter((a) => optionalAddonIds.includes(a.slug) || optionalAddonIds.includes(String(a.id)))
          .map((a) => a.name)
      : optionalAddons
          .filter((o) => optionalAddonIds.includes(o.id))
          .map((o) => o.name);

  return {
    businessLabel: business?.label ?? "—",
    objectiveLabel: objective?.label ?? "—",
    platforms,
    modules,
    addons: addonItems,
  };
}

export function resolveAppFormatLabel(appFormatId: string): string {
  return appFormats.find((f) => f.id === appFormatId)?.name ?? appFormatId;
}

export function mapAddonsForProposal(
  optionalAddonIds: string[],
  catalogAddons: Addon[],
) {
  if (catalogAddons.length > 0 && catalogAddons[0].id > 0) {
    return catalogAddons
      .filter((a) => optionalAddonIds.includes(a.slug))
      .map(addonToDisplayItem);
  }
  return optionalAddons
    .filter((o) => optionalAddonIds.includes(o.id))
    .map((o) => ({
      id: o.id,
      slug: o.moduleId ?? o.id,
      name: o.name,
      description: o.description,
      category: o.category,
      price: o.oneTimePrice,
      recurring: false,
    }));
}

export function buildPlanningProposalLabels(
  planning: PlanningProjectState,
  apiPlans?: Plan[] | null,
) {
  const type = appTypes.find((t) => t.id === planning.projectType);
  const features = projectFeatures
    .filter((f) => planning.featureIds.includes(f.id))
    .map((f) => f.label);
  const platforms = planningPlatforms
    .filter((p) => planning.platformIds.includes(p.id))
    .map((p) => p.label);
  const optionals = optionalServices
    .filter((o) => planning.optionalServiceIds.includes(o.id))
    .map((o) => o.label);
  const style = visualStyles.find((s) => s.id === planning.visualStyle);
  const plan = findPlanningPlanView(planning.planningPlanSlug, apiPlans);

  return {
    appTypeLabel: type ? `${type.emoji} ${type.label}` : "—",
    objective: planning.projectObjective || "—",
    features,
    platforms,
    optionals,
    visualStyleLabel: style?.label ?? "—",
    planLabel: plan ? `${plan.emoji} ${plan.name}` : "—",
    references: [
      ...planning.referenceLinks,
      ...planning.referenceFileNames,
    ],
  };
}

export function createProposalSnapshot(input: {
  userId: number;
  discovery: DiscoveryState;
  subscriptionSlug: string;
  plan?: Plan;
  appFormatId: string;
  developmentModuleIds: string[];
  optionalAddonIds: string[];
  billingCycle: BillingCycle;
  includeStrategicPlanning: boolean;
  planning?: PlanningProjectState;
  quote: CommercialQuote;
  status?: ProposalStatus;
  paymentGateway?: string;
  sessionId?: string;
  paymentStatus?: "pending" | "paid";
  projectStatus?: "draft" | "planning" | "development";
}): ClientProposalSnapshot {
  const now = new Date().toISOString();
  return {
    id: `prop-${input.userId}-${Date.now()}`,
    userId: input.userId,
    createdAt: now,
    updatedAt: now,
    status: input.status ?? "proposal",
    discovery: input.discovery,
    subscriptionSlug: input.subscriptionSlug,
    planName: input.plan?.name ?? input.subscriptionSlug,
    planId: input.plan?.id,
    appFormatId: input.appFormatId,
    developmentModuleIds: input.developmentModuleIds,
    optionalAddonIds: input.optionalAddonIds,
    billingCycle: input.billingCycle,
    includeStrategicPlanning: input.includeStrategicPlanning,
    planning: input.planning,
    paymentGateway: input.paymentGateway,
    sessionId: input.sessionId,
    quote: input.quote,
    paymentStatus: input.paymentStatus ?? "pending",
    projectStatus: input.projectStatus ?? "planning",
  };
}