TYPESCRIPT analytics.ts

import api from './client';

export interface CrmSummary {
  companies: number;
  contacts: number;
  deals: number;
  pipeline_value: number;
}

export interface PipelineStage {
  name: string;
  count: number;
  value: number;
}

export interface ContactsAnalytics {
  total: number;
  growth_30d: string;
  avg_lifecycle_days: number;
  source_breakdown: Record<string, number>;
}

export interface DealsVelocity {
  avg_days_to_close: number;
  monthly_wins: number;
  win_rate: number;
  pipeline_velocity_score: number;
}

export interface ForecastData {
  monthly_revenue: number;
  monthly_deals: number;
  quarterly_revenue: number;
  quarterly_deals: number;
}

// -- Revenue Forecast interfaces --

export interface ForecastMonth {
  month: string;
  label: string;
  actual: number;
  likely: number;
  best: number;
  conservative: number;
}

export interface RevenueForecastResponse {
  forecast: {
    trailing_actuals: ForecastMonth[];
    forecast_months: ForecastMonth[];
    confidence_score: number;
    avg_monthly_actual: number;
    total_pipeline_value: number;
    total_weighted_value: number;
    open_deals_count: number;
  };
}

// -- Pipeline Health interfaces --

export interface AtRiskDeal {
  deal_name: string;
  amount: number;
  stage: string;
  expected_close_date: string | null;
  days_overdue: number;
}

export interface StageDistribution {
  stage: string;
  count: number;
  value: number;
}

export interface StageConversion {
  stage: string;
  count: number;
  next_stage: string | null;
  conversion_pct: number;
}

export interface PipelineForecastResponse {
  pipeline_health: {
    health_score: number;
    total_pipeline_value: number;
    weighted_pipeline_value: number;
    open_deals_count: number;
    coverage_ratio: number;
    avg_monthly_won_revenue: number;
    growth_rate_pct: number;
    this_month_new_deals: number;
    last_month_new_deals: number;
  };
  at_risk_deals: AtRiskDeal[];
  stage_distribution: StageDistribution[];
  stage_conversion: StageConversion[];
}

// -- KPI interfaces --

export interface KPIMetric {
  label: string;
  category: string;
  value: number;
  previous_value: number;
  unit: string;
  pct_change: number;
  trend: 'up' | 'down' | 'flat';
  invert_trend?: boolean;
}

export interface KPIsResponse {
  kpis: KPIMetric[];
  period_days: number;
  current_period: {
    start: string;
    end: string;
  };
  previous_period: {
    start: string;
    end: string;
  };
}

// -- Existing analytics API --

export const analyticsApi = {
  getCrmSummary: async (): Promise<CrmSummary> => {
    const { data } = await api.get<CrmSummary>('/api/analytics/crm/summary');
    return data;
  },

  getPipeline: async (): Promise<{ stages: PipelineStage[] }> => {
    const { data } = await api.get<{ stages: PipelineStage[] }>('/api/analytics/pipeline');
    return data;
  },

  getContacts: async (): Promise<ContactsAnalytics> => {
    const { data } = await api.get<ContactsAnalytics>('/api/analytics/contacts');
    return data;
  },

  getDealsVelocity: async (): Promise<DealsVelocity> => {
    const { data } = await api.get<DealsVelocity>('/api/analytics/deals/velocity');
    return data;
  },

  getForecasts: async (): Promise<ForecastData> => {
    const { data } = await api.get<ForecastData>('/api/analytics/forecasts');
    return data;
  },
};

// -- Forecast API --

export const forecastApi = {
  getRevenueForecast: async (): Promise<RevenueForecastResponse> => {
    const { data } = await api.get<RevenueForecastResponse>('/api/analytics/forecast/revenue');
    return data;
  },

  getPipelineForecast: async (): Promise<PipelineForecastResponse> => {
    const { data } = await api.get<PipelineForecastResponse>('/api/analytics/forecast/pipeline');
    return data;
  },

  getKPIs: async (period_days?: number): Promise<KPIsResponse> => {
    const params = period_days ? { period_days } : {};
    const { data } = await api.get<KPIsResponse>('/api/analytics/kpis', { params });
    return data;
  },
};

// -- Cascading Goals interfaces --

export interface GoalMetric {
  id: string;
  metric_name: string;
  target_value: number;
  actual_value: number;
  unit: string;
  period: string;
  progress_percentage: number;
}

export interface GoalNode {
  id: string;
  name: string;
  description: string;
  level: 'org' | 'department' | 'team' | 'rep';
  target_value: number;
  current_value: number;
  unit: string;
  status: string;
  progress_percentage: number;
  parent_goal_id: string | null;
  assigned_to: string | null;
  company_id?: string;
  weight: number;
  start_date: string | null;
  end_date: string | null;
  metrics: GoalMetric[];
  sub_goals: GoalNode[];
}

export interface CascadeLevel {
  id: string;
  name: string;
  target_value: number;
  current_value: number;
  progress_percentage: number;
  parent_goal_id?: string | null;
}

export interface CascadeSummary {
  org_target: number;
  org_current: number;
  org_progress_percentage: number;
  dept_targets: CascadeLevel[];
  dept_total_target: number;
  dept_total_current: number;
  team_targets: CascadeLevel[];
  team_total_target: number;
  team_total_current: number;
  rep_targets: CascadeLevel[];
  rep_total_target: number;
  rep_total_current: number;
  total_cascade: number;
  cascade_variance: number;
}

export interface GoalsResponse {
  goals: GoalNode[];
  cascade_summary: CascadeSummary;
  total_goals: number;
}

export interface UpdateGoalProgressResponse {
  goal: GoalNode;
  cascade_summary: CascadeSummary;
}

export interface CreateGoalPayload {
  name: string;
  description?: string;
  target_value: number;
  current_value?: number;
  level: 'org' | 'department' | 'team' | 'rep';
  parent_goal_id?: string | null;
  company_id: string;
  status?: string;
  assigned_to?: string | null;
  start_date?: string;
  end_date?: string;
  unit?: string;
  weight?: number;
}

export interface CreateGoalResponse {
  goal: GoalNode;
  cascade_summary: CascadeSummary;
}

export interface DeleteGoalResponse {
  deleted: string;
  cascade_summary: CascadeSummary;
}

// -- Goal filter params --

export interface GoalsFilterParams {
  company_id?: string;
  level?: 'org' | 'department' | 'team' | 'rep';
  status?: 'active' | 'completed' | 'paused' | 'cancelled';
  parent_goal_id?: string;
  search?: string;
  start_date_gte?: string;
  end_date_lte?: string;
  include_cascade?: boolean;
}

// -- Goal metrics --

export interface CreateMetricPayload {
  metric_name: string;
  target_value: number;
  actual_value?: number;
  unit?: string;
  period?: string;
  period_start?: string;
  period_end?: string;
}

export interface UpdateMetricPayload extends Partial<CreateMetricPayload> {}

// -- Analytics users --

export interface AnalyticsUser {
  id: string;
  email: string;
  full_name: string;
  role: string;
  company_role?: string;
}

// -- Goals API --

export const goalsApi = {
  getGoals: async (params?: GoalsFilterParams): Promise<GoalsResponse> => {
    const { data } = await api.get<GoalsResponse>('/api/analytics/goals', { params });
    return data;
  },

  getGoalMetrics: async (goalId: string): Promise<{ metrics: GoalMetric[] }> => {
    const { data } = await api.get<{ metrics: GoalMetric[] }>(`/api/analytics/goals/${goalId}/metrics`);
    return data;
  },

  createGoalMetric: async (goalId: string, payload: CreateMetricPayload): Promise<{ metric: GoalMetric }> => {
    const { data } = await api.post<{ metric: GoalMetric }>(`/api/analytics/goals/${goalId}/metrics`, payload);
    return data;
  },

  updateGoalMetric: async (goalId: string, metricId: string, payload: UpdateMetricPayload): Promise<{ metric: GoalMetric }> => {
    const { data } = await api.put<{ metric: GoalMetric }>(`/api/analytics/goals/${goalId}/metrics/${metricId}`, payload);
    return data;
  },

  deleteGoalMetric: async (goalId: string, metricId: string): Promise<{ deleted: string }> => {
    const { data } = await api.delete<{ deleted: string }>(`/api/analytics/goals/${goalId}/metrics/${metricId}`);
    return data;
  },

  updateProgress: async (goalId: string, currentValue: number, rollUp?: boolean): Promise<UpdateGoalProgressResponse> => {
    const { data } = await api.put<UpdateGoalProgressResponse>(
      `/api/analytics/goals/${goalId}/progress`,
      { current_value: currentValue, roll_up: rollUp ?? false }
    );
    return data;
  },

  createGoal: async (payload: CreateGoalPayload): Promise<CreateGoalResponse> => {
    const { data } = await api.post<CreateGoalResponse>('/api/analytics/goals', payload);
    return data;
  },

  updateGoal: async (goalId: string, payload: Partial<CreateGoalPayload>): Promise<CreateGoalResponse> => {
    const { data } = await api.put<CreateGoalResponse>(`/api/analytics/goals/${goalId}`, payload);
    return data;
  },

  deleteGoal: async (goalId: string): Promise<DeleteGoalResponse> => {
    const { data } = await api.delete<DeleteGoalResponse>(`/api/analytics/goals/${goalId}`);
    return data;
  },

  getUsers: async (): Promise<{ users: AnalyticsUser[] }> => {
    const { data } = await api.get<{ users: AnalyticsUser[] }>('/api/analytics/users');
    return data;
  },
};

// -- Strategic Intelligence interfaces --

export interface TrendPoint {
  month: string;
  label: string;
  actual: number;
  budget: number;
}

export interface StrategicOverview {
  period: string;
  period_label: string;
  budget: number;
  actual: number;
  forecast: number;
  variance: number;
  variance_pct: number;
  trend: TrendPoint[];
}

export interface WaterfallStep {
  label: string;
  value: number;
  cumulative: number;
  color: string;
}

export interface MarketMixPoint {
  source: string;
  value: number;
}

export interface WaterfallData {
  waterfall: WaterfallStep[];
  budget: number;
  actual: number;
  components: {
    pipeline_contribution: number;
    new_deals: number;
    deal_size_variance: number;
    conversion_rate_variance: number;
    churn_cancellations: number;
  };
  market_mix: MarketMixPoint[];
}

export interface RootCauseNode {
  label: string;
  value: number;
  details?: Record<string, unknown>;
  children: RootCauseNode[];
}

export interface RootCauseTree {
  root: {
    label: string;
    value: number;
    budget: number;
    actual: number;
    children: RootCauseNode[];
  };
}

export interface ContributionFactor {
  name: string;
  label: string;
  value: number;
  direction: 'positive' | 'negative' | 'neutral';
  description: string;
  recommendation: string;
  percentage: number;
}

export interface SourceBreakdown {
  source: string;
  current: number;
  previous: number;
  change: number;
}

export interface ContributionAnalysis {
  total_variance: number;
  period: string;
  factors: ContributionFactor[];
  source_breakdown: SourceBreakdown[];
}

// -- Strategic Intelligence API --

export const strategicApi = {
  getOverview: async (): Promise<StrategicOverview> => {
    const { data } = await api.get<StrategicOverview>('/api/analytics/strategic-intelligence/overview');
    return data;
  },

  getWaterfall: async (): Promise<WaterfallData> => {
    const { data } = await api.get<WaterfallData>('/api/analytics/strategic-intelligence/waterfall');
    return data;
  },

  getRootCause: async (): Promise<RootCauseTree> => {
    const { data } = await api.get<RootCauseTree>('/api/analytics/strategic-intelligence/root-cause');
    return data;
  },

  getContribution: async (): Promise<ContributionAnalysis> => {
    const { data } = await api.get<ContributionAnalysis>('/api/analytics/strategic-intelligence/contribution');
    return data;
  },
};

// -- Scale Optimization interfaces --

export interface ScaleOverview {
  total_spend_30d: number;
  total_spend_90d: number;
  total_conversions: number;
  attributed_revenue: number;
  overall_roas: number;
  avg_ltv_cac: number;
  total_active_campaigns: number;
  campaigns_by_channel: Record<string, number>;
  period: string;
}

export interface RunRateData {
  ytd_revenue: number;
  annual_target: number | null;
  run_rate: number | null;
  months_elapsed: number;
  months_remaining: number;
  pace: 'on_track' | 'behind' | null;
  required_monthly: number | null;
  remaining_needed: number | null;
}

export interface ChannelPerformance {
  channel: string;
  source_service: string;
  spend: number;
  impressions: number;
  clicks: number;
  conversions: number;
  ctr: number;
  cpc: number;
  attributed_revenue: number;
  roas: number;
  ltv_cac: number;
  cac: number;
  trend: 'up' | 'down' | 'flat';
}

export interface MatrixCell {
  spend: number;
  revenue: number;
  roas: number;
}

export interface MatrixRow {
  dimension: string;
  type: 'product' | 'market';
  [channel: string]: string | MatrixCell;
}

export interface MatrixResponse {
  rows: MatrixRow[];
  channels: string[];
  channel_names: Record<string, string>;
}

export interface Recommendation {
  id: string;
  action: string;
  description: string;
  from_channel: string;
  from_channel_key: string;
  to_channel: string;
  to_channel_key: string;
  move_amount: number;
  current_roas_from: number;
  current_roas_to: number;
  projected_revenue: number;
  current_revenue: number;
  revenue_lift: number;
  revenue_lift_pct: number;
  confidence: 'high' | 'medium' | 'low';
  reason: string;
}

export interface RecommendationsResponse {
  recommendations: Recommendation[];
  total_channels: number;
  overall_avg_roas: number;
  channel_summary: Array<{
    source: string;
    name: string;
    spend: number;
    roas: number;
    revenue: number;
  }>;
  generated_at: string;
}

// -- Scale Optimization API --

export const scaleOptimizationApi = {
  getOverview: async (): Promise<ScaleOverview> => {
    const { data } = await api.get<ScaleOverview>('/api/analytics/scale-optimization/overview');
    return data;
  },

  getRunRate: async (): Promise<RunRateData> => {
    const { data } = await api.get<RunRateData>('/api/analytics/scale-optimization/run-rate');
    return data;
  },

  getChannels: async (): Promise<{ channels: ChannelPerformance[] }> => {
    const { data } = await api.get<{ channels: ChannelPerformance[] }>('/api/analytics/scale-optimization/channels');
    return data;
  },

  getMatrix: async (): Promise<MatrixResponse> => {
    const { data } = await api.get<MatrixResponse>('/api/analytics/scale-optimization/matrix');
    return data;
  },

  getRecommendations: async (): Promise<RecommendationsResponse> => {
    const { data } = await api.get<RecommendationsResponse>('/api/analytics/scale-optimization/recommendations');
    return data;
  },
};